github.com/Minish144/prototool-arm64@v1.3.0/example/gen/proto/go/foo/foo.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: foo/foo.proto

package foopb

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import types "github.com/gogo/protobuf/types"
import sub "github.com/uber/prototool/example/gen/proto/go/sub"
import _ "google.golang.org/genproto/googleapis/api/annotations"

import strconv "strconv"

import strings "strings"
import reflect "reflect"
import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"

import context "golang.org/x/net/context"
import grpc "google.golang.org/grpc"

import io "io"

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

// Hello is a hello.
type Hello int32

const (
	HELLO_INVALID Hello = 0
	HELLO_UNSET   Hello = 1
	HELLO_TREE    Hello = 2
	HELLO_BALLOON Hello = 3
)

var Hello_name = map[int32]string{
	0: "HELLO_INVALID",
	1: "HELLO_UNSET",
	2: "HELLO_TREE",
	3: "HELLO_BALLOON",
}
var Hello_value = map[string]int32{
	"HELLO_INVALID": 0,
	"HELLO_UNSET":   1,
	"HELLO_TREE":    2,
	"HELLO_BALLOON": 3,
}

func (Hello) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{0}
}

// Bar is a bar.
type Bar int32

const (
	BAR_INVALID Bar = 0
)

var Bar_name = map[int32]string{
	0: "BAR_INVALID",
}
var Bar_value = map[string]int32{
	"BAR_INVALID": 0,
}

func (Bar) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{1}
}

// Baz is a baz.
type Foo_Bar_Baz int32

const (
	FOO_BAR_BAZ_INVALID Foo_Bar_Baz = 0
)

var Foo_Bar_Baz_name = map[int32]string{
	0: "FOO_BAR_BAZ_INVALID",
}
var Foo_Bar_Baz_value = map[string]int32{
	"FOO_BAR_BAZ_INVALID": 0,
}

func (Foo_Bar_Baz) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{0, 0, 0}
}

// Bat is a bat.
type Foo_Bar_Bat int32

const (
	FOO_BAR_BAT_INVALID Foo_Bar_Bat = 0
)

var Foo_Bar_Bat_name = map[int32]string{
	0: "FOO_BAR_BAT_INVALID",
}
var Foo_Bar_Bat_value = map[string]int32{
	"FOO_BAR_BAT_INVALID": 0,
}

func (Foo_Bar_Bat) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{0, 0, 1}
}

// Foo is a foo.
type Foo struct {
	Bar                  *Foo_Bar `protobuf:"bytes,1,opt,name=bar" json:"bar,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Foo) Reset()      { *m = Foo{} }
func (*Foo) ProtoMessage() {}
func (*Foo) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{0}
}
func (m *Foo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Foo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Foo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Foo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Foo.Merge(dst, src)
}
func (m *Foo) XXX_Size() int {
	return m.Size()
}
func (m *Foo) XXX_DiscardUnknown() {
	xxx_messageInfo_Foo.DiscardUnknown(m)
}

var xxx_messageInfo_Foo proto.InternalMessageInfo

func (m *Foo) GetBar() *Foo_Bar {
	if m != nil {
		return m.Bar
	}
	return nil
}

// Bar is a bar.
type Foo_Bar struct {
	Baz                  Foo_Bar_Baz `protobuf:"varint,1,opt,name=baz,proto3,enum=foo.Foo_Bar_Baz" json:"baz,omitempty"`
	Bat                  Foo_Bar_Bat `protobuf:"varint,2,opt,name=bat,proto3,enum=foo.Foo_Bar_Bat" json:"bat,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *Foo_Bar) Reset()      { *m = Foo_Bar{} }
func (*Foo_Bar) ProtoMessage() {}
func (*Foo_Bar) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{0, 0}
}
func (m *Foo_Bar) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Foo_Bar) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Foo_Bar.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Foo_Bar) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Foo_Bar.Merge(dst, src)
}
func (m *Foo_Bar) XXX_Size() int {
	return m.Size()
}
func (m *Foo_Bar) XXX_DiscardUnknown() {
	xxx_messageInfo_Foo_Bar.DiscardUnknown(m)
}

var xxx_messageInfo_Foo_Bar proto.InternalMessageInfo

func (m *Foo_Bar) GetBaz() Foo_Bar_Baz {
	if m != nil {
		return m.Baz
	}
	return FOO_BAR_BAZ_INVALID
}

func (m *Foo_Bar) GetBat() Foo_Bar_Bat {
	if m != nil {
		return m.Bat
	}
	return FOO_BAR_BAT_INVALID
}

// Barr is a barr.
type Barr struct {
	Hello                int64            `protobuf:"varint,1,opt,name=hello,proto3" json:"hello,omitempty"`
	Dep                  *Dep             `protobuf:"bytes,2,opt,name=dep" json:"dep,omitempty"`
	Timestamp            *types.Timestamp `protobuf:"bytes,3,opt,name=timestamp" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *Barr) Reset()      { *m = Barr{} }
func (*Barr) ProtoMessage() {}
func (*Barr) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{1}
}
func (m *Barr) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Barr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Barr.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Barr) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Barr.Merge(dst, src)
}
func (m *Barr) XXX_Size() int {
	return m.Size()
}
func (m *Barr) XXX_DiscardUnknown() {
	xxx_messageInfo_Barr.DiscardUnknown(m)
}

var xxx_messageInfo_Barr proto.InternalMessageInfo

func (m *Barr) GetHello() int64 {
	if m != nil {
		return m.Hello
	}
	return 0
}

func (m *Barr) GetDep() *Dep {
	if m != nil {
		return m.Dep
	}
	return nil
}

func (m *Barr) GetTimestamp() *types.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

// Another is another message.
type Another struct {
	One     int64            `protobuf:"varint,1,opt,name=one,proto3" json:"one,omitempty"`
	Two     string           `protobuf:"bytes,2,opt,name=two,proto3" json:"two,omitempty"`
	Another *Another         `protobuf:"bytes,3,opt,name=another" json:"another,omitempty"`
	Four    []string         `protobuf:"bytes,4,rep,name=four" json:"four,omitempty"`
	Hello   Hello            `protobuf:"varint,5,opt,name=hello,proto3,enum=foo.Hello" json:"hello,omitempty"`
	M       map[string]int64 `protobuf:"bytes,6,rep,name=m" json:"m,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	// Types that are valid to be assigned to OneofOneof:
	//	*Another_Seven
	//	*Another_Eight
	OneofOneof           isAnother_OneofOneof `protobuf_oneof:"oneof_oneof"`
	Nine                 []*Another           `protobuf:"bytes,9,rep,name=nine" json:"nine,omitempty"`
	Duration             *types.Duration      `protobuf:"bytes,10,opt,name=duration" json:"duration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Another) Reset()      { *m = Another{} }
func (*Another) ProtoMessage() {}
func (*Another) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{2}
}
func (m *Another) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Another) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Another.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Another) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Another.Merge(dst, src)
}
func (m *Another) XXX_Size() int {
	return m.Size()
}
func (m *Another) XXX_DiscardUnknown() {
	xxx_messageInfo_Another.DiscardUnknown(m)
}

var xxx_messageInfo_Another proto.InternalMessageInfo

type isAnother_OneofOneof interface {
	isAnother_OneofOneof()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Another_Seven struct {
	Seven int64 `protobuf:"varint,7,opt,name=seven,proto3,oneof"`
}
type Another_Eight struct {
	Eight string `protobuf:"bytes,8,opt,name=eight,proto3,oneof"`
}

func (*Another_Seven) isAnother_OneofOneof() {}
func (*Another_Eight) isAnother_OneofOneof() {}

func (m *Another) GetOneofOneof() isAnother_OneofOneof {
	if m != nil {
		return m.OneofOneof
	}
	return nil
}

func (m *Another) GetOne() int64 {
	if m != nil {
		return m.One
	}
	return 0
}

func (m *Another) GetTwo() string {
	if m != nil {
		return m.Two
	}
	return ""
}

func (m *Another) GetAnother() *Another {
	if m != nil {
		return m.Another
	}
	return nil
}

func (m *Another) GetFour() []string {
	if m != nil {
		return m.Four
	}
	return nil
}

func (m *Another) GetHello() Hello {
	if m != nil {
		return m.Hello
	}
	return HELLO_INVALID
}

func (m *Another) GetM() map[string]int64 {
	if m != nil {
		return m.M
	}
	return nil
}

func (m *Another) GetSeven() int64 {
	if x, ok := m.GetOneofOneof().(*Another_Seven); ok {
		return x.Seven
	}
	return 0
}

func (m *Another) GetEight() string {
	if x, ok := m.GetOneofOneof().(*Another_Eight); ok {
		return x.Eight
	}
	return ""
}

func (m *Another) GetNine() []*Another {
	if m != nil {
		return m.Nine
	}
	return nil
}

func (m *Another) GetDuration() *types.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Another) 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 _Another_OneofMarshaler, _Another_OneofUnmarshaler, _Another_OneofSizer, []interface{}{
		(*Another_Seven)(nil),
		(*Another_Eight)(nil),
	}
}

func _Another_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Another)
	// oneof_oneof
	switch x := m.OneofOneof.(type) {
	case *Another_Seven:
		_ = b.EncodeVarint(7<<3 | proto.WireVarint)
		_ = b.EncodeVarint(uint64(x.Seven))
	case *Another_Eight:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		_ = b.EncodeStringBytes(x.Eight)
	case nil:
	default:
		return fmt.Errorf("Another.OneofOneof has unexpected type %T", x)
	}
	return nil
}

func _Another_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Another)
	switch tag {
	case 7: // oneof_oneof.seven
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.OneofOneof = &Another_Seven{int64(x)}
		return true, err
	case 8: // oneof_oneof.eight
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeStringBytes()
		m.OneofOneof = &Another_Eight{x}
		return true, err
	default:
		return false, nil
	}
}

func _Another_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Another)
	// oneof_oneof
	switch x := m.OneofOneof.(type) {
	case *Another_Seven:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.Seven))
	case *Another_Eight:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(len(x.Eight)))
		n += len(x.Eight)
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// HasWKT has Well-Known Types.
type HasWKT struct {
	Duration             *types.Duration `protobuf:"bytes,1,opt,name=duration" json:"duration,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *HasWKT) Reset()      { *m = HasWKT{} }
func (*HasWKT) ProtoMessage() {}
func (*HasWKT) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{3}
}
func (m *HasWKT) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *HasWKT) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_HasWKT.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *HasWKT) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HasWKT.Merge(dst, src)
}
func (m *HasWKT) XXX_Size() int {
	return m.Size()
}
func (m *HasWKT) XXX_DiscardUnknown() {
	xxx_messageInfo_HasWKT.DiscardUnknown(m)
}

var xxx_messageInfo_HasWKT proto.InternalMessageInfo

func (m *HasWKT) GetDuration() *types.Duration {
	if m != nil {
		return m.Duration
	}
	return nil
}

// Bazz is a bazzzz.
type Bazz struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Bazz) Reset()      { *m = Bazz{} }
func (*Bazz) ProtoMessage() {}
func (*Bazz) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{4}
}
func (m *Bazz) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Bazz) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Bazz.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *Bazz) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Bazz.Merge(dst, src)
}
func (m *Bazz) XXX_Size() int {
	return m.Size()
}
func (m *Bazz) XXX_DiscardUnknown() {
	xxx_messageInfo_Bazz.DiscardUnknown(m)
}

var xxx_messageInfo_Bazz proto.InternalMessageInfo

// BarRequest is a bar request.
type BarRequest struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BarRequest) Reset()      { *m = BarRequest{} }
func (*BarRequest) ProtoMessage() {}
func (*BarRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{5}
}
func (m *BarRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BarRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BarRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *BarRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BarRequest.Merge(dst, src)
}
func (m *BarRequest) XXX_Size() int {
	return m.Size()
}
func (m *BarRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_BarRequest.DiscardUnknown(m)
}

var xxx_messageInfo_BarRequest proto.InternalMessageInfo

func (m *BarRequest) GetId() int64 {
	if m != nil {
		return m.Id
	}
	return 0
}

// FooResponse is an foo response.
type FooResponse struct {
	Dep                  *Dep     `protobuf:"bytes,1,opt,name=dep" json:"dep,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FooResponse) Reset()      { *m = FooResponse{} }
func (*FooResponse) ProtoMessage() {}
func (*FooResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{6}
}
func (m *FooResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FooResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FooResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *FooResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FooResponse.Merge(dst, src)
}
func (m *FooResponse) XXX_Size() int {
	return m.Size()
}
func (m *FooResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FooResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FooResponse proto.InternalMessageInfo

func (m *FooResponse) GetDep() *Dep {
	if m != nil {
		return m.Dep
	}
	return nil
}

type ExclamationRequest struct {
	Value                string   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExclamationRequest) Reset()      { *m = ExclamationRequest{} }
func (*ExclamationRequest) ProtoMessage() {}
func (*ExclamationRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{7}
}
func (m *ExclamationRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExclamationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExclamationRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *ExclamationRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExclamationRequest.Merge(dst, src)
}
func (m *ExclamationRequest) XXX_Size() int {
	return m.Size()
}
func (m *ExclamationRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExclamationRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExclamationRequest proto.InternalMessageInfo

func (m *ExclamationRequest) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type ExclamationResponse struct {
	Value                string   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExclamationResponse) Reset()      { *m = ExclamationResponse{} }
func (*ExclamationResponse) ProtoMessage() {}
func (*ExclamationResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_foo_985cfaf62b75c4c1, []int{8}
}
func (m *ExclamationResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExclamationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExclamationResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (dst *ExclamationResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExclamationResponse.Merge(dst, src)
}
func (m *ExclamationResponse) XXX_Size() int {
	return m.Size()
}
func (m *ExclamationResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ExclamationResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ExclamationResponse proto.InternalMessageInfo

func (m *ExclamationResponse) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func init() {
	proto.RegisterType((*Foo)(nil), "foo.Foo")
	proto.RegisterType((*Foo_Bar)(nil), "foo.Foo.Bar")
	proto.RegisterType((*Barr)(nil), "foo.Barr")
	proto.RegisterType((*Another)(nil), "foo.Another")
	proto.RegisterMapType((map[string]int64)(nil), "foo.Another.MEntry")
	proto.RegisterType((*HasWKT)(nil), "foo.HasWKT")
	proto.RegisterType((*Bazz)(nil), "foo.Bazz")
	proto.RegisterType((*BarRequest)(nil), "foo.BarRequest")
	proto.RegisterType((*FooResponse)(nil), "foo.FooResponse")
	proto.RegisterType((*ExclamationRequest)(nil), "foo.ExclamationRequest")
	proto.RegisterType((*ExclamationResponse)(nil), "foo.ExclamationResponse")
	proto.RegisterEnum("foo.Hello", Hello_name, Hello_value)
	proto.RegisterEnum("foo.Bar", Bar_name, Bar_value)
	proto.RegisterEnum("foo.Foo_Bar_Baz", Foo_Bar_Baz_name, Foo_Bar_Baz_value)
	proto.RegisterEnum("foo.Foo_Bar_Bat", Foo_Bar_Bat_name, Foo_Bar_Bat_value)
}
func (x Hello) String() string {
	s, ok := Hello_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Bar) String() string {
	s, ok := Bar_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Foo_Bar_Baz) String() string {
	s, ok := Foo_Bar_Baz_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Foo_Bar_Bat) String() string {
	s, ok := Foo_Bar_Bat_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Foo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Foo)
	if !ok {
		that2, ok := that.(Foo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Bar.Equal(that1.Bar) {
		return false
	}
	return true
}
func (this *Foo_Bar) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Foo_Bar)
	if !ok {
		that2, ok := that.(Foo_Bar)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Baz != that1.Baz {
		return false
	}
	if this.Bat != that1.Bat {
		return false
	}
	return true
}
func (this *Barr) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Barr)
	if !ok {
		that2, ok := that.(Barr)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Hello != that1.Hello {
		return false
	}
	if !this.Dep.Equal(that1.Dep) {
		return false
	}
	if !this.Timestamp.Equal(that1.Timestamp) {
		return false
	}
	return true
}
func (this *Another) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Another)
	if !ok {
		that2, ok := that.(Another)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.One != that1.One {
		return false
	}
	if this.Two != that1.Two {
		return false
	}
	if !this.Another.Equal(that1.Another) {
		return false
	}
	if len(this.Four) != len(that1.Four) {
		return false
	}
	for i := range this.Four {
		if this.Four[i] != that1.Four[i] {
			return false
		}
	}
	if this.Hello != that1.Hello {
		return false
	}
	if len(this.M) != len(that1.M) {
		return false
	}
	for i := range this.M {
		if this.M[i] != that1.M[i] {
			return false
		}
	}
	if that1.OneofOneof == nil {
		if this.OneofOneof != nil {
			return false
		}
	} else if this.OneofOneof == nil {
		return false
	} else if !this.OneofOneof.Equal(that1.OneofOneof) {
		return false
	}
	if len(this.Nine) != len(that1.Nine) {
		return false
	}
	for i := range this.Nine {
		if !this.Nine[i].Equal(that1.Nine[i]) {
			return false
		}
	}
	if !this.Duration.Equal(that1.Duration) {
		return false
	}
	return true
}
func (this *Another_Seven) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Another_Seven)
	if !ok {
		that2, ok := that.(Another_Seven)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Seven != that1.Seven {
		return false
	}
	return true
}
func (this *Another_Eight) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Another_Eight)
	if !ok {
		that2, ok := that.(Another_Eight)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Eight != that1.Eight {
		return false
	}
	return true
}
func (this *HasWKT) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*HasWKT)
	if !ok {
		that2, ok := that.(HasWKT)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Duration.Equal(that1.Duration) {
		return false
	}
	return true
}
func (this *Bazz) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Bazz)
	if !ok {
		that2, ok := that.(Bazz)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}
func (this *BarRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*BarRequest)
	if !ok {
		that2, ok := that.(BarRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	return true
}
func (this *FooResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*FooResponse)
	if !ok {
		that2, ok := that.(FooResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Dep.Equal(that1.Dep) {
		return false
	}
	return true
}
func (this *ExclamationRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExclamationRequest)
	if !ok {
		that2, ok := that.(ExclamationRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *ExclamationResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ExclamationResponse)
	if !ok {
		that2, ok := that.(ExclamationResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Value != that1.Value {
		return false
	}
	return true
}
func (this *Foo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&foopb.Foo{")
	if this.Bar != nil {
		s = append(s, "Bar: "+fmt.Sprintf("%#v", this.Bar)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Foo_Bar) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&foopb.Foo_Bar{")
	s = append(s, "Baz: "+fmt.Sprintf("%#v", this.Baz)+",\n")
	s = append(s, "Bat: "+fmt.Sprintf("%#v", this.Bat)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Barr) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&foopb.Barr{")
	s = append(s, "Hello: "+fmt.Sprintf("%#v", this.Hello)+",\n")
	if this.Dep != nil {
		s = append(s, "Dep: "+fmt.Sprintf("%#v", this.Dep)+",\n")
	}
	if this.Timestamp != nil {
		s = append(s, "Timestamp: "+fmt.Sprintf("%#v", this.Timestamp)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Another) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 14)
	s = append(s, "&foopb.Another{")
	s = append(s, "One: "+fmt.Sprintf("%#v", this.One)+",\n")
	s = append(s, "Two: "+fmt.Sprintf("%#v", this.Two)+",\n")
	if this.Another != nil {
		s = append(s, "Another: "+fmt.Sprintf("%#v", this.Another)+",\n")
	}
	s = append(s, "Four: "+fmt.Sprintf("%#v", this.Four)+",\n")
	s = append(s, "Hello: "+fmt.Sprintf("%#v", this.Hello)+",\n")
	keysForM := make([]string, 0, len(this.M))
	for k, _ := range this.M {
		keysForM = append(keysForM, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForM)
	mapStringForM := "map[string]int64{"
	for _, k := range keysForM {
		mapStringForM += fmt.Sprintf("%#v: %#v,", k, this.M[k])
	}
	mapStringForM += "}"
	if this.M != nil {
		s = append(s, "M: "+mapStringForM+",\n")
	}
	if this.OneofOneof != nil {
		s = append(s, "OneofOneof: "+fmt.Sprintf("%#v", this.OneofOneof)+",\n")
	}
	if this.Nine != nil {
		s = append(s, "Nine: "+fmt.Sprintf("%#v", this.Nine)+",\n")
	}
	if this.Duration != nil {
		s = append(s, "Duration: "+fmt.Sprintf("%#v", this.Duration)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Another_Seven) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&foopb.Another_Seven{` +
		`Seven:` + fmt.Sprintf("%#v", this.Seven) + `}`}, ", ")
	return s
}
func (this *Another_Eight) GoString() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&foopb.Another_Eight{` +
		`Eight:` + fmt.Sprintf("%#v", this.Eight) + `}`}, ", ")
	return s
}
func (this *HasWKT) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&foopb.HasWKT{")
	if this.Duration != nil {
		s = append(s, "Duration: "+fmt.Sprintf("%#v", this.Duration)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Bazz) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&foopb.Bazz{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *BarRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&foopb.BarRequest{")
	s = append(s, "Id: "+fmt.Sprintf("%#v", this.Id)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *FooResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&foopb.FooResponse{")
	if this.Dep != nil {
		s = append(s, "Dep: "+fmt.Sprintf("%#v", this.Dep)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExclamationRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&foopb.ExclamationRequest{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ExclamationResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&foopb.ExclamationResponse{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringFoo(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

// 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

// Client API for HelloService service

type HelloServiceClient interface {
	// Foo does a foo.
	Foo(ctx context.Context, in *sub.Dep, opts ...grpc.CallOption) (*FooResponse, error)
	// Bar does a bar.
	Bar(ctx context.Context, in *BarRequest, opts ...grpc.CallOption) (*Dep, error)
}

type helloServiceClient struct {
	cc *grpc.ClientConn
}

func NewHelloServiceClient(cc *grpc.ClientConn) HelloServiceClient {
	return &helloServiceClient{cc}
}

func (c *helloServiceClient) Foo(ctx context.Context, in *sub.Dep, opts ...grpc.CallOption) (*FooResponse, error) {
	out := new(FooResponse)
	err := c.cc.Invoke(ctx, "/foo.HelloService/Foo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *helloServiceClient) Bar(ctx context.Context, in *BarRequest, opts ...grpc.CallOption) (*Dep, error) {
	out := new(Dep)
	err := c.cc.Invoke(ctx, "/foo.HelloService/Bar", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for HelloService service

type HelloServiceServer interface {
	// Foo does a foo.
	Foo(context.Context, *sub.Dep) (*FooResponse, error)
	// Bar does a bar.
	Bar(context.Context, *BarRequest) (*Dep, error)
}

func RegisterHelloServiceServer(s *grpc.Server, srv HelloServiceServer) {
	s.RegisterService(&_HelloService_serviceDesc, srv)
}

func _HelloService_Foo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(sub.Dep)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HelloServiceServer).Foo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/foo.HelloService/Foo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HelloServiceServer).Foo(ctx, req.(*sub.Dep))
	}
	return interceptor(ctx, in, info, handler)
}

func _HelloService_Bar_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BarRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HelloServiceServer).Bar(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/foo.HelloService/Bar",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HelloServiceServer).Bar(ctx, req.(*BarRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _HelloService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "foo.HelloService",
	HandlerType: (*HelloServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Foo",
			Handler:    _HelloService_Foo_Handler,
		},
		{
			MethodName: "Bar",
			Handler:    _HelloService_Bar_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "foo/foo.proto",
}

// Client API for ExcitedService service

type ExcitedServiceClient interface {
	// Exclamation adds an exclamation to the request value.
	Exclamation(ctx context.Context, in *ExclamationRequest, opts ...grpc.CallOption) (*ExclamationResponse, error)
	// ExclamationClientStream adds an exclamation to the combined request values.
	ExclamationClientStream(ctx context.Context, opts ...grpc.CallOption) (ExcitedService_ExclamationClientStreamClient, error)
	// ExclamationServerStream adds an exclamation to the request value
	// and streams each character as a response.
	ExclamationServerStream(ctx context.Context, in *ExclamationRequest, opts ...grpc.CallOption) (ExcitedService_ExclamationServerStreamClient, error)
	// ExclamationBidiStream adds an exclamation to the each request value.
	ExclamationBidiStream(ctx context.Context, opts ...grpc.CallOption) (ExcitedService_ExclamationBidiStreamClient, error)
}

type excitedServiceClient struct {
	cc *grpc.ClientConn
}

func NewExcitedServiceClient(cc *grpc.ClientConn) ExcitedServiceClient {
	return &excitedServiceClient{cc}
}

func (c *excitedServiceClient) Exclamation(ctx context.Context, in *ExclamationRequest, opts ...grpc.CallOption) (*ExclamationResponse, error) {
	out := new(ExclamationResponse)
	err := c.cc.Invoke(ctx, "/foo.ExcitedService/Exclamation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *excitedServiceClient) ExclamationClientStream(ctx context.Context, opts ...grpc.CallOption) (ExcitedService_ExclamationClientStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ExcitedService_serviceDesc.Streams[0], "/foo.ExcitedService/ExclamationClientStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &excitedServiceExclamationClientStreamClient{stream}
	return x, nil
}

type ExcitedService_ExclamationClientStreamClient interface {
	Send(*ExclamationRequest) error
	CloseAndRecv() (*ExclamationResponse, error)
	grpc.ClientStream
}

type excitedServiceExclamationClientStreamClient struct {
	grpc.ClientStream
}

func (x *excitedServiceExclamationClientStreamClient) Send(m *ExclamationRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *excitedServiceExclamationClientStreamClient) CloseAndRecv() (*ExclamationResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(ExclamationResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *excitedServiceClient) ExclamationServerStream(ctx context.Context, in *ExclamationRequest, opts ...grpc.CallOption) (ExcitedService_ExclamationServerStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ExcitedService_serviceDesc.Streams[1], "/foo.ExcitedService/ExclamationServerStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &excitedServiceExclamationServerStreamClient{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 ExcitedService_ExclamationServerStreamClient interface {
	Recv() (*ExclamationResponse, error)
	grpc.ClientStream
}

type excitedServiceExclamationServerStreamClient struct {
	grpc.ClientStream
}

func (x *excitedServiceExclamationServerStreamClient) Recv() (*ExclamationResponse, error) {
	m := new(ExclamationResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *excitedServiceClient) ExclamationBidiStream(ctx context.Context, opts ...grpc.CallOption) (ExcitedService_ExclamationBidiStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ExcitedService_serviceDesc.Streams[2], "/foo.ExcitedService/ExclamationBidiStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &excitedServiceExclamationBidiStreamClient{stream}
	return x, nil
}

type ExcitedService_ExclamationBidiStreamClient interface {
	Send(*ExclamationRequest) error
	Recv() (*ExclamationResponse, error)
	grpc.ClientStream
}

type excitedServiceExclamationBidiStreamClient struct {
	grpc.ClientStream
}

func (x *excitedServiceExclamationBidiStreamClient) Send(m *ExclamationRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *excitedServiceExclamationBidiStreamClient) Recv() (*ExclamationResponse, error) {
	m := new(ExclamationResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for ExcitedService service

type ExcitedServiceServer interface {
	// Exclamation adds an exclamation to the request value.
	Exclamation(context.Context, *ExclamationRequest) (*ExclamationResponse, error)
	// ExclamationClientStream adds an exclamation to the combined request values.
	ExclamationClientStream(ExcitedService_ExclamationClientStreamServer) error
	// ExclamationServerStream adds an exclamation to the request value
	// and streams each character as a response.
	ExclamationServerStream(*ExclamationRequest, ExcitedService_ExclamationServerStreamServer) error
	// ExclamationBidiStream adds an exclamation to the each request value.
	ExclamationBidiStream(ExcitedService_ExclamationBidiStreamServer) error
}

func RegisterExcitedServiceServer(s *grpc.Server, srv ExcitedServiceServer) {
	s.RegisterService(&_ExcitedService_serviceDesc, srv)
}

func _ExcitedService_Exclamation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExclamationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ExcitedServiceServer).Exclamation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/foo.ExcitedService/Exclamation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ExcitedServiceServer).Exclamation(ctx, req.(*ExclamationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ExcitedService_ExclamationClientStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ExcitedServiceServer).ExclamationClientStream(&excitedServiceExclamationClientStreamServer{stream})
}

type ExcitedService_ExclamationClientStreamServer interface {
	SendAndClose(*ExclamationResponse) error
	Recv() (*ExclamationRequest, error)
	grpc.ServerStream
}

type excitedServiceExclamationClientStreamServer struct {
	grpc.ServerStream
}

func (x *excitedServiceExclamationClientStreamServer) SendAndClose(m *ExclamationResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *excitedServiceExclamationClientStreamServer) Recv() (*ExclamationRequest, error) {
	m := new(ExclamationRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _ExcitedService_ExclamationServerStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ExclamationRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ExcitedServiceServer).ExclamationServerStream(m, &excitedServiceExclamationServerStreamServer{stream})
}

type ExcitedService_ExclamationServerStreamServer interface {
	Send(*ExclamationResponse) error
	grpc.ServerStream
}

type excitedServiceExclamationServerStreamServer struct {
	grpc.ServerStream
}

func (x *excitedServiceExclamationServerStreamServer) Send(m *ExclamationResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _ExcitedService_ExclamationBidiStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(ExcitedServiceServer).ExclamationBidiStream(&excitedServiceExclamationBidiStreamServer{stream})
}

type ExcitedService_ExclamationBidiStreamServer interface {
	Send(*ExclamationResponse) error
	Recv() (*ExclamationRequest, error)
	grpc.ServerStream
}

type excitedServiceExclamationBidiStreamServer struct {
	grpc.ServerStream
}

func (x *excitedServiceExclamationBidiStreamServer) Send(m *ExclamationResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *excitedServiceExclamationBidiStreamServer) Recv() (*ExclamationRequest, error) {
	m := new(ExclamationRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _ExcitedService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "foo.ExcitedService",
	HandlerType: (*ExcitedServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Exclamation",
			Handler:    _ExcitedService_Exclamation_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ExclamationClientStream",
			Handler:       _ExcitedService_ExclamationClientStream_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "ExclamationServerStream",
			Handler:       _ExcitedService_ExclamationServerStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ExclamationBidiStream",
			Handler:       _ExcitedService_ExclamationBidiStream_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "foo/foo.proto",
}

func (m *Foo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Foo) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Bar != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Bar.Size()))
		n1, err := m.Bar.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	return i, nil
}

func (m *Foo_Bar) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Foo_Bar) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Baz != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Baz))
	}
	if m.Bat != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Bat))
	}
	return i, nil
}

func (m *Barr) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Barr) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Hello != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Hello))
	}
	if m.Dep != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Dep.Size()))
		n2, err := m.Dep.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Timestamp != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Timestamp.Size()))
		n3, err := m.Timestamp.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}

func (m *Another) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Another) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.One != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.One))
	}
	if len(m.Two) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintFoo(dAtA, i, uint64(len(m.Two)))
		i += copy(dAtA[i:], m.Two)
	}
	if m.Another != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Another.Size()))
		n4, err := m.Another.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if len(m.Four) > 0 {
		for _, s := range m.Four {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.Hello != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Hello))
	}
	if len(m.M) > 0 {
		for k, _ := range m.M {
			dAtA[i] = 0x32
			i++
			v := m.M[k]
			mapSize := 1 + len(k) + sovFoo(uint64(len(k))) + 1 + sovFoo(uint64(v))
			i = encodeVarintFoo(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintFoo(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x10
			i++
			i = encodeVarintFoo(dAtA, i, uint64(v))
		}
	}
	if m.OneofOneof != nil {
		nn5, err := m.OneofOneof.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn5
	}
	if len(m.Nine) > 0 {
		for _, msg := range m.Nine {
			dAtA[i] = 0x4a
			i++
			i = encodeVarintFoo(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Duration != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Duration.Size()))
		n6, err := m.Duration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}

func (m *Another_Seven) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x38
	i++
	i = encodeVarintFoo(dAtA, i, uint64(m.Seven))
	return i, nil
}
func (m *Another_Eight) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	dAtA[i] = 0x42
	i++
	i = encodeVarintFoo(dAtA, i, uint64(len(m.Eight)))
	i += copy(dAtA[i:], m.Eight)
	return i, nil
}
func (m *HasWKT) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *HasWKT) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Duration != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Duration.Size()))
		n7, err := m.Duration.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}

func (m *Bazz) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Bazz) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *BarRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BarRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Id))
	}
	return i, nil
}

func (m *FooResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FooResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Dep != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFoo(dAtA, i, uint64(m.Dep.Size()))
		n8, err := m.Dep.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}

func (m *ExclamationRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExclamationRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFoo(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	return i, nil
}

func (m *ExclamationResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ExclamationResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintFoo(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	return i, nil
}

func encodeVarintFoo(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Foo) Size() (n int) {
	var l int
	_ = l
	if m.Bar != nil {
		l = m.Bar.Size()
		n += 1 + l + sovFoo(uint64(l))
	}
	return n
}

func (m *Foo_Bar) Size() (n int) {
	var l int
	_ = l
	if m.Baz != 0 {
		n += 1 + sovFoo(uint64(m.Baz))
	}
	if m.Bat != 0 {
		n += 1 + sovFoo(uint64(m.Bat))
	}
	return n
}

func (m *Barr) Size() (n int) {
	var l int
	_ = l
	if m.Hello != 0 {
		n += 1 + sovFoo(uint64(m.Hello))
	}
	if m.Dep != nil {
		l = m.Dep.Size()
		n += 1 + l + sovFoo(uint64(l))
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovFoo(uint64(l))
	}
	return n
}

func (m *Another) Size() (n int) {
	var l int
	_ = l
	if m.One != 0 {
		n += 1 + sovFoo(uint64(m.One))
	}
	l = len(m.Two)
	if l > 0 {
		n += 1 + l + sovFoo(uint64(l))
	}
	if m.Another != nil {
		l = m.Another.Size()
		n += 1 + l + sovFoo(uint64(l))
	}
	if len(m.Four) > 0 {
		for _, s := range m.Four {
			l = len(s)
			n += 1 + l + sovFoo(uint64(l))
		}
	}
	if m.Hello != 0 {
		n += 1 + sovFoo(uint64(m.Hello))
	}
	if len(m.M) > 0 {
		for k, v := range m.M {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovFoo(uint64(len(k))) + 1 + sovFoo(uint64(v))
			n += mapEntrySize + 1 + sovFoo(uint64(mapEntrySize))
		}
	}
	if m.OneofOneof != nil {
		n += m.OneofOneof.Size()
	}
	if len(m.Nine) > 0 {
		for _, e := range m.Nine {
			l = e.Size()
			n += 1 + l + sovFoo(uint64(l))
		}
	}
	if m.Duration != nil {
		l = m.Duration.Size()
		n += 1 + l + sovFoo(uint64(l))
	}
	return n
}

func (m *Another_Seven) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovFoo(uint64(m.Seven))
	return n
}
func (m *Another_Eight) Size() (n int) {
	var l int
	_ = l
	l = len(m.Eight)
	n += 1 + l + sovFoo(uint64(l))
	return n
}
func (m *HasWKT) Size() (n int) {
	var l int
	_ = l
	if m.Duration != nil {
		l = m.Duration.Size()
		n += 1 + l + sovFoo(uint64(l))
	}
	return n
}

func (m *Bazz) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *BarRequest) Size() (n int) {
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovFoo(uint64(m.Id))
	}
	return n
}

func (m *FooResponse) Size() (n int) {
	var l int
	_ = l
	if m.Dep != nil {
		l = m.Dep.Size()
		n += 1 + l + sovFoo(uint64(l))
	}
	return n
}

func (m *ExclamationRequest) Size() (n int) {
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovFoo(uint64(l))
	}
	return n
}

func (m *ExclamationResponse) Size() (n int) {
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovFoo(uint64(l))
	}
	return n
}

func sovFoo(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozFoo(x uint64) (n int) {
	return sovFoo(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Foo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Foo{`,
		`Bar:` + strings.Replace(fmt.Sprintf("%v", this.Bar), "Foo_Bar", "Foo_Bar", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Foo_Bar) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Foo_Bar{`,
		`Baz:` + fmt.Sprintf("%v", this.Baz) + `,`,
		`Bat:` + fmt.Sprintf("%v", this.Bat) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Barr) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Barr{`,
		`Hello:` + fmt.Sprintf("%v", this.Hello) + `,`,
		`Dep:` + strings.Replace(fmt.Sprintf("%v", this.Dep), "Dep", "Dep", 1) + `,`,
		`Timestamp:` + strings.Replace(fmt.Sprintf("%v", this.Timestamp), "Timestamp", "types.Timestamp", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Another) String() string {
	if this == nil {
		return "nil"
	}
	keysForM := make([]string, 0, len(this.M))
	for k, _ := range this.M {
		keysForM = append(keysForM, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForM)
	mapStringForM := "map[string]int64{"
	for _, k := range keysForM {
		mapStringForM += fmt.Sprintf("%v: %v,", k, this.M[k])
	}
	mapStringForM += "}"
	s := strings.Join([]string{`&Another{`,
		`One:` + fmt.Sprintf("%v", this.One) + `,`,
		`Two:` + fmt.Sprintf("%v", this.Two) + `,`,
		`Another:` + strings.Replace(fmt.Sprintf("%v", this.Another), "Another", "Another", 1) + `,`,
		`Four:` + fmt.Sprintf("%v", this.Four) + `,`,
		`Hello:` + fmt.Sprintf("%v", this.Hello) + `,`,
		`M:` + mapStringForM + `,`,
		`OneofOneof:` + fmt.Sprintf("%v", this.OneofOneof) + `,`,
		`Nine:` + strings.Replace(fmt.Sprintf("%v", this.Nine), "Another", "Another", 1) + `,`,
		`Duration:` + strings.Replace(fmt.Sprintf("%v", this.Duration), "Duration", "types.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Another_Seven) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Another_Seven{`,
		`Seven:` + fmt.Sprintf("%v", this.Seven) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Another_Eight) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Another_Eight{`,
		`Eight:` + fmt.Sprintf("%v", this.Eight) + `,`,
		`}`,
	}, "")
	return s
}
func (this *HasWKT) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&HasWKT{`,
		`Duration:` + strings.Replace(fmt.Sprintf("%v", this.Duration), "Duration", "types.Duration", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Bazz) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Bazz{`,
		`}`,
	}, "")
	return s
}
func (this *BarRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&BarRequest{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`}`,
	}, "")
	return s
}
func (this *FooResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&FooResponse{`,
		`Dep:` + strings.Replace(fmt.Sprintf("%v", this.Dep), "Dep", "Dep", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExclamationRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExclamationRequest{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ExclamationResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ExclamationResponse{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringFoo(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Foo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Foo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Foo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bar", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Bar == nil {
				m.Bar = &Foo_Bar{}
			}
			if err := m.Bar.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Foo_Bar) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Bar: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bar: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Baz", wireType)
			}
			m.Baz = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Baz |= (Foo_Bar_Baz(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bat", wireType)
			}
			m.Bat = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bat |= (Foo_Bar_Bat(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Barr) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Barr: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Barr: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hello", wireType)
			}
			m.Hello = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hello |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dep", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dep == nil {
				m.Dep = &Dep{}
			}
			if err := m.Dep.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Another) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Another: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Another: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field One", wireType)
			}
			m.One = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.One |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Two", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Two = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Another", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Another == nil {
				m.Another = &Another{}
			}
			if err := m.Another.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Four", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Four = append(m.Four, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hello", wireType)
			}
			m.Hello = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Hello |= (Hello(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field M", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.M == nil {
				m.M = make(map[string]int64)
			}
			var mapkey string
			var mapvalue int64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowFoo
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFoo
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthFoo
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowFoo
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= (int64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipFoo(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthFoo
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.M[mapkey] = mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seven", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OneofOneof = &Another_Seven{v}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Eight", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OneofOneof = &Another_Eight{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nine", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nine = append(m.Nine, &Another{})
			if err := m.Nine[len(m.Nine)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Duration == nil {
				m.Duration = &types.Duration{}
			}
			if err := m.Duration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HasWKT) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: HasWKT: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HasWKT: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Duration == nil {
				m.Duration = &types.Duration{}
			}
			if err := m.Duration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Bazz) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Bazz: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bazz: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BarRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BarRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BarRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FooResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FooResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FooResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dep", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dep == nil {
				m.Dep = &Dep{}
			}
			if err := m.Dep.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExclamationRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExclamationRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExclamationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExclamationResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ExclamationResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExclamationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthFoo
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipFoo(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthFoo
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipFoo(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowFoo
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowFoo
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthFoo
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowFoo
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipFoo(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthFoo = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowFoo   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("foo/foo.proto", fileDescriptor_foo_985cfaf62b75c4c1) }

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