test.pb.go

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

package main

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 empty "github.com/golang/protobuf/ptypes/empty"
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 (
	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 State int32

const (
	State_INVALID        State = 0
	State_INITIAL        State = 1
	State_PENDING        State = 2
	State_RUNNING        State = 3
	State_PAUSED         State = 4
	State_AWAITING_INPUT State = 5
	State_CANCELLING     State = 6
	State_COMPLETE       State = 7
	State_CANCELLED      State = 8
	State_FAILED         State = 9
)

var State_name = map[int32]string{
	0: "INVALID",
	1: "INITIAL",
	2: "PENDING",
	3: "RUNNING",
	4: "PAUSED",
	5: "AWAITING_INPUT",
	6: "CANCELLING",
	7: "COMPLETE",
	8: "CANCELLED",
	9: "FAILED",
}
var State_value = map[string]int32{
	"INVALID":        0,
	"INITIAL":        1,
	"PENDING":        2,
	"RUNNING":        3,
	"PAUSED":         4,
	"AWAITING_INPUT": 5,
	"CANCELLING":     6,
	"COMPLETE":       7,
	"CANCELLED":      8,
	"FAILED":         9,
}

func (x State) Enum() *State {
	p := new(State)
	*p = x
	return p
}
func (x State) String() string {
	return proto.EnumName(State_name, int32(x))
}
func (x *State) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(State_value, data, "State")
	if err != nil {
		return err
	}
	*x = State(value)
	return nil
}
func (State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_test_cf54b8462ccc4096, []int{0}
}

type Void int32

const (
	Void_VOID Void = 0
)

var Void_name = map[int32]string{
	0: "VOID",
}
var Void_value = map[string]int32{
	"VOID": 0,
}

func (x Void) Enum() *Void {
	p := new(Void)
	*p = x
	return p
}
func (x Void) String() string {
	return proto.EnumName(Void_name, int32(x))
}
func (x *Void) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Void_value, data, "Void")
	if err != nil {
		return err
	}
	*x = Void(value)
	return nil
}
func (Void) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_test_cf54b8462ccc4096, []int{1}
}

type Person struct {
	Id      *uint64  `protobuf:"varint,1,req,name=id" json:"id,omitempty"`
	Name    *string  `protobuf:"bytes,2,req,name=name" json:"name,omitempty"`
	Address *Address `protobuf:"bytes,3,opt,name=address" json:"address,omitempty"`
	Xyz     *float64 `protobuf:"fixed64,4,opt,name=xyz,def=3.14159" json:"xyz,omitempty"`
	Title   *string  `protobuf:"bytes,5,opt,name=title,def=overseer" json:"title,omitempty"`
	Labels  []string `protobuf:"bytes,6,rep,name=labels" json:"labels,omitempty"`
	IsReal  *bool    `protobuf:"varint,7,opt,name=is_real,json=isReal,def=1" json:"is_real,omitempty"`
	Opaque  []byte   `protobuf:"bytes,8,opt,name=opaque,def=\\001\\002\\003\\004" json:"opaque,omitempty"`
	// Types that are valid to be assigned to Relative:
	//	*Person_Parent
	//	*Person_Sibling
	//	*Person_Child
	//	*Person_None
	Relative             isPerson_Relative `protobuf_oneof:"relative"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_Person proto.InternalMessageInfo

const Default_Person_Xyz float64 = 3.14159
const Default_Person_Title string = "overseer"
const Default_Person_IsReal bool = true

var Default_Person_Opaque []byte = []byte("\x01\x02\x03\x04")

func (m *Person) GetId() uint64 {
	if m != nil && m.Id != nil {
		return *m.Id
	}
	return 0
}

func (m *Person) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *Person) GetAddress() *Address {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *Person) GetXyz() float64 {
	if m != nil && m.Xyz != nil {
		return *m.Xyz
	}
	return Default_Person_Xyz
}

func (m *Person) GetTitle() string {
	if m != nil && m.Title != nil {
		return *m.Title
	}
	return Default_Person_Title
}

func (m *Person) GetLabels() []string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *Person) GetIsReal() bool {
	if m != nil && m.IsReal != nil {
		return *m.IsReal
	}
	return Default_Person_IsReal
}

func (m *Person) GetOpaque() []byte {
	if m != nil && m.Opaque != nil {
		return m.Opaque
	}
	return append([]byte(nil), Default_Person_Opaque...)
}

type isPerson_Relative interface {
	isPerson_Relative()
}

type Person_Parent struct {
	Parent *Person `protobuf:"bytes,9,opt,name=parent,oneof"`
}

type Person_Sibling struct {
	Sibling *Person `protobuf:"bytes,10,opt,name=sibling,oneof"`
}

type Person_Child struct {
	Child *Person `protobuf:"bytes,11,opt,name=child,oneof"`
}

type Person_None struct {
	None Void `protobuf:"varint,12,opt,name=none,enum=test.Void,oneof"`
}

func (*Person_Parent) isPerson_Relative() {}

func (*Person_Sibling) isPerson_Relative() {}

func (*Person_Child) isPerson_Relative() {}

func (*Person_None) isPerson_Relative() {}

func (m *Person) GetRelative() isPerson_Relative {
	if m != nil {
		return m.Relative
	}
	return nil
}

func (m *Person) GetParent() *Person {
	if x, ok := m.GetRelative().(*Person_Parent); ok {
		return x.Parent
	}
	return nil
}

func (m *Person) GetSibling() *Person {
	if x, ok := m.GetRelative().(*Person_Sibling); ok {
		return x.Sibling
	}
	return nil
}

func (m *Person) GetChild() *Person {
	if x, ok := m.GetRelative().(*Person_Child); ok {
		return x.Child
	}
	return nil
}

func (m *Person) GetNone() Void {
	if x, ok := m.GetRelative().(*Person_None); ok {
		return x.None
	}
	return Void_VOID
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Person) 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 _Person_OneofMarshaler, _Person_OneofUnmarshaler, _Person_OneofSizer, []interface{}{
		(*Person_Parent)(nil),
		(*Person_Sibling)(nil),
		(*Person_Child)(nil),
		(*Person_None)(nil),
	}
}

func _Person_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Person)
	// relative
	switch x := m.Relative.(type) {
	case *Person_Parent:
		b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Parent); err != nil {
			return err
		}
	case *Person_Sibling:
		b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Sibling); err != nil {
			return err
		}
	case *Person_Child:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Child); err != nil {
			return err
		}
	case *Person_None:
		b.EncodeVarint(12<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.None))
	case nil:
	default:
		return fmt.Errorf("Person.Relative has unexpected type %T", x)
	}
	return nil
}

func _Person_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Person)
	switch tag {
	case 9: // relative.parent
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Person)
		err := b.DecodeMessage(msg)
		m.Relative = &Person_Parent{msg}
		return true, err
	case 10: // relative.sibling
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Person)
		err := b.DecodeMessage(msg)
		m.Relative = &Person_Sibling{msg}
		return true, err
	case 11: // relative.child
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Person)
		err := b.DecodeMessage(msg)
		m.Relative = &Person_Child{msg}
		return true, err
	case 12: // relative.none
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Relative = &Person_None{Void(x)}
		return true, err
	default:
		return false, nil
	}
}

func _Person_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Person)
	// relative
	switch x := m.Relative.(type) {
	case *Person_Parent:
		s := proto.Size(x.Parent)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Person_Sibling:
		s := proto.Size(x.Sibling)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Person_Child:
		s := proto.Size(x.Child)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Person_None:
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(x.None))
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type Address struct {
	Line1                *string  `protobuf:"bytes,1,req,name=line1" json:"line1,omitempty"`
	Line2                *string  `protobuf:"bytes,2,opt,name=line2" json:"line2,omitempty"`
	City                 *string  `protobuf:"bytes,3,req,name=city" json:"city,omitempty"`
	State                *string  `protobuf:"bytes,4,req,name=state" json:"state,omitempty"`
	Zip                  *uint32  `protobuf:"varint,5,req,name=zip" json:"zip,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `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 fileDescriptor_test_cf54b8462ccc4096, []int{1}
}
func (m *Address) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Address.Unmarshal(m, b)
}
func (m *Address) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Address.Marshal(b, m, deterministic)
}
func (dst *Address) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Address.Merge(dst, src)
}
func (m *Address) XXX_Size() int {
	return xxx_messageInfo_Address.Size(m)
}
func (m *Address) XXX_DiscardUnknown() {
	xxx_messageInfo_Address.DiscardUnknown(m)
}

var xxx_messageInfo_Address proto.InternalMessageInfo

func (m *Address) GetLine1() string {
	if m != nil && m.Line1 != nil {
		return *m.Line1
	}
	return ""
}

func (m *Address) GetLine2() string {
	if m != nil && m.Line2 != nil {
		return *m.Line2
	}
	return ""
}

func (m *Address) GetCity() string {
	if m != nil && m.City != nil {
		return *m.City
	}
	return ""
}

func (m *Address) GetState() string {
	if m != nil && m.State != nil {
		return *m.State
	}
	return ""
}

func (m *Address) GetZip() uint32 {
	if m != nil && m.Zip != nil {
		return *m.Zip
	}
	return 0
}

type WellKnowns struct {
	Now                  *timestamp.Timestamp    `protobuf:"bytes,1,req,name=now" json:"now,omitempty"`
	Past                 *timestamp.Timestamp    `protobuf:"bytes,2,opt,name=past" json:"past,omitempty"`
	Futures              []*timestamp.Timestamp  `protobuf:"bytes,3,rep,name=futures" json:"futures,omitempty"`
	Period               *duration.Duration      `protobuf:"bytes,4,req,name=period" json:"period,omitempty"`
	NextInterval         *duration.Duration      `protobuf:"bytes,5,opt,name=next_interval,json=nextInterval" json:"next_interval,omitempty"`
	HistoryIntervals     []*duration.Duration    `protobuf:"bytes,6,rep,name=history_intervals,json=historyIntervals" json:"history_intervals,omitempty"`
	Neat                 *any.Any                `protobuf:"bytes,7,req,name=neat" json:"neat,omitempty"`
	Extra                *any.Any                `protobuf:"bytes,8,opt,name=extra" json:"extra,omitempty"`
	Extensions           []*any.Any              `protobuf:"bytes,9,rep,name=extensions" json:"extensions,omitempty"`
	Object               *_struct.Struct         `protobuf:"bytes,10,req,name=object" json:"object,omitempty"`
	OptionalObject       *_struct.Struct         `protobuf:"bytes,11,opt,name=optional_object,json=optionalObject" json:"optional_object,omitempty"`
	Objects              []*_struct.Struct       `protobuf:"bytes,12,rep,name=objects" json:"objects,omitempty"`
	Value                *_struct.Value          `protobuf:"bytes,13,req,name=value" json:"value,omitempty"`
	OptionalValue        *_struct.Value          `protobuf:"bytes,14,opt,name=optional_value,json=optionalValue" json:"optional_value,omitempty"`
	Values               []*_struct.Value        `protobuf:"bytes,15,rep,name=values" json:"values,omitempty"`
	List                 *_struct.ListValue      `protobuf:"bytes,16,req,name=list" json:"list,omitempty"`
	OptionalList         *_struct.ListValue      `protobuf:"bytes,17,opt,name=optional_list,json=optionalList" json:"optional_list,omitempty"`
	Lists                []*_struct.ListValue    `protobuf:"bytes,18,rep,name=lists" json:"lists,omitempty"`
	Bytes                *wrappers.BytesValue    `protobuf:"bytes,19,req,name=bytes" json:"bytes,omitempty"`
	OptionalBytes        *wrappers.BytesValue    `protobuf:"bytes,20,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty"`
	ListOBytes           []*wrappers.BytesValue  `protobuf:"bytes,21,rep,name=list_o_bytes,json=listOBytes" json:"list_o_bytes,omitempty"`
	String_              *wrappers.StringValue   `protobuf:"bytes,22,req,name=string" json:"string,omitempty"`
	OptionalString       *wrappers.StringValue   `protobuf:"bytes,23,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
	ListOStrings         []*wrappers.StringValue `protobuf:"bytes,24,rep,name=list_o_strings,json=listOStrings" json:"list_o_strings,omitempty"`
	Bool                 *wrappers.BoolValue     `protobuf:"bytes,25,req,name=bool" json:"bool,omitempty"`
	OptionalBool         *wrappers.BoolValue     `protobuf:"bytes,26,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
	ListOBools           []*wrappers.BoolValue   `protobuf:"bytes,27,rep,name=list_o_bools,json=listOBools" json:"list_o_bools,omitempty"`
	Double               *wrappers.DoubleValue   `protobuf:"bytes,28,req,name=double" json:"double,omitempty"`
	OptionalDouble       *wrappers.DoubleValue   `protobuf:"bytes,29,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
	ListODoubles         []*wrappers.DoubleValue `protobuf:"bytes,30,rep,name=list_o_doubles,json=listODoubles" json:"list_o_doubles,omitempty"`
	Float                *wrappers.FloatValue    `protobuf:"bytes,31,req,name=float" json:"float,omitempty"`
	OptionalFloat        *wrappers.FloatValue    `protobuf:"bytes,32,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
	ListOFloats          []*wrappers.FloatValue  `protobuf:"bytes,33,rep,name=list_o_floats,json=listOFloats" json:"list_o_floats,omitempty"`
	SmallInt             *wrappers.Int32Value    `protobuf:"bytes,34,req,name=small_int,json=smallInt" json:"small_int,omitempty"`
	OptionalSmallInt     *wrappers.Int32Value    `protobuf:"bytes,35,opt,name=optional_small_int,json=optionalSmallInt" json:"optional_small_int,omitempty"`
	ListOSmallInts       []*wrappers.Int32Value  `protobuf:"bytes,36,rep,name=list_o_small_ints,json=listOSmallInts" json:"list_o_small_ints,omitempty"`
	BigInt               *wrappers.Int64Value    `protobuf:"bytes,37,req,name=big_int,json=bigInt" json:"big_int,omitempty"`
	OptionalBigInt       *wrappers.Int64Value    `protobuf:"bytes,38,opt,name=optional_big_int,json=optionalBigInt" json:"optional_big_int,omitempty"`
	ListOBigInts         []*wrappers.Int64Value  `protobuf:"bytes,39,rep,name=list_o_big_ints,json=listOBigInts" json:"list_o_big_ints,omitempty"`
	SmallId              *wrappers.UInt32Value   `protobuf:"bytes,40,req,name=small_id,json=smallId" json:"small_id,omitempty"`
	OptionalSmallId      *wrappers.UInt32Value   `protobuf:"bytes,41,opt,name=optional_small_id,json=optionalSmallId" json:"optional_small_id,omitempty"`
	ListOSmallIds        []*wrappers.UInt32Value `protobuf:"bytes,42,rep,name=list_o_small_ids,json=listOSmallIds" json:"list_o_small_ids,omitempty"`
	BigId                *wrappers.UInt64Value   `protobuf:"bytes,43,req,name=big_id,json=bigId" json:"big_id,omitempty"`
	OptionalBigId        *wrappers.UInt64Value   `protobuf:"bytes,44,opt,name=optional_big_id,json=optionalBigId" json:"optional_big_id,omitempty"`
	ListOBigIds          []*wrappers.UInt64Value `protobuf:"bytes,45,rep,name=list_o_big_ids,json=listOBigIds" json:"list_o_big_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

var xxx_messageInfo_WellKnowns proto.InternalMessageInfo

func (m *WellKnowns) GetNow() *timestamp.Timestamp {
	if m != nil {
		return m.Now
	}
	return nil
}

func (m *WellKnowns) GetPast() *timestamp.Timestamp {
	if m != nil {
		return m.Past
	}
	return nil
}

func (m *WellKnowns) GetFutures() []*timestamp.Timestamp {
	if m != nil {
		return m.Futures
	}
	return nil
}

func (m *WellKnowns) GetPeriod() *duration.Duration {
	if m != nil {
		return m.Period
	}
	return nil
}

func (m *WellKnowns) GetNextInterval() *duration.Duration {
	if m != nil {
		return m.NextInterval
	}
	return nil
}

func (m *WellKnowns) GetHistoryIntervals() []*duration.Duration {
	if m != nil {
		return m.HistoryIntervals
	}
	return nil
}

func (m *WellKnowns) GetNeat() *any.Any {
	if m != nil {
		return m.Neat
	}
	return nil
}

func (m *WellKnowns) GetExtra() *any.Any {
	if m != nil {
		return m.Extra
	}
	return nil
}

func (m *WellKnowns) GetExtensions() []*any.Any {
	if m != nil {
		return m.Extensions
	}
	return nil
}

func (m *WellKnowns) GetObject() *_struct.Struct {
	if m != nil {
		return m.Object
	}
	return nil
}

func (m *WellKnowns) GetOptionalObject() *_struct.Struct {
	if m != nil {
		return m.OptionalObject
	}
	return nil
}

func (m *WellKnowns) GetObjects() []*_struct.Struct {
	if m != nil {
		return m.Objects
	}
	return nil
}

func (m *WellKnowns) GetValue() *_struct.Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *WellKnowns) GetOptionalValue() *_struct.Value {
	if m != nil {
		return m.OptionalValue
	}
	return nil
}

func (m *WellKnowns) GetValues() []*_struct.Value {
	if m != nil {
		return m.Values
	}
	return nil
}

func (m *WellKnowns) GetList() *_struct.ListValue {
	if m != nil {
		return m.List
	}
	return nil
}

func (m *WellKnowns) GetOptionalList() *_struct.ListValue {
	if m != nil {
		return m.OptionalList
	}
	return nil
}

func (m *WellKnowns) GetLists() []*_struct.ListValue {
	if m != nil {
		return m.Lists
	}
	return nil
}

func (m *WellKnowns) GetBytes() *wrappers.BytesValue {
	if m != nil {
		return m.Bytes
	}
	return nil
}

func (m *WellKnowns) GetOptionalBytes() *wrappers.BytesValue {
	if m != nil {
		return m.OptionalBytes
	}
	return nil
}

func (m *WellKnowns) GetListOBytes() []*wrappers.BytesValue {
	if m != nil {
		return m.ListOBytes
	}
	return nil
}

func (m *WellKnowns) GetString_() *wrappers.StringValue {
	if m != nil {
		return m.String_
	}
	return nil
}

func (m *WellKnowns) GetOptionalString() *wrappers.StringValue {
	if m != nil {
		return m.OptionalString
	}
	return nil
}

func (m *WellKnowns) GetListOStrings() []*wrappers.StringValue {
	if m != nil {
		return m.ListOStrings
	}
	return nil
}

func (m *WellKnowns) GetBool() *wrappers.BoolValue {
	if m != nil {
		return m.Bool
	}
	return nil
}

func (m *WellKnowns) GetOptionalBool() *wrappers.BoolValue {
	if m != nil {
		return m.OptionalBool
	}
	return nil
}

func (m *WellKnowns) GetListOBools() []*wrappers.BoolValue {
	if m != nil {
		return m.ListOBools
	}
	return nil
}

func (m *WellKnowns) GetDouble() *wrappers.DoubleValue {
	if m != nil {
		return m.Double
	}
	return nil
}

func (m *WellKnowns) GetOptionalDouble() *wrappers.DoubleValue {
	if m != nil {
		return m.OptionalDouble
	}
	return nil
}

func (m *WellKnowns) GetListODoubles() []*wrappers.DoubleValue {
	if m != nil {
		return m.ListODoubles
	}
	return nil
}

func (m *WellKnowns) GetFloat() *wrappers.FloatValue {
	if m != nil {
		return m.Float
	}
	return nil
}

func (m *WellKnowns) GetOptionalFloat() *wrappers.FloatValue {
	if m != nil {
		return m.OptionalFloat
	}
	return nil
}

func (m *WellKnowns) GetListOFloats() []*wrappers.FloatValue {
	if m != nil {
		return m.ListOFloats
	}
	return nil
}

func (m *WellKnowns) GetSmallInt() *wrappers.Int32Value {
	if m != nil {
		return m.SmallInt
	}
	return nil
}

func (m *WellKnowns) GetOptionalSmallInt() *wrappers.Int32Value {
	if m != nil {
		return m.OptionalSmallInt
	}
	return nil
}

func (m *WellKnowns) GetListOSmallInts() []*wrappers.Int32Value {
	if m != nil {
		return m.ListOSmallInts
	}
	return nil
}

func (m *WellKnowns) GetBigInt() *wrappers.Int64Value {
	if m != nil {
		return m.BigInt
	}
	return nil
}

func (m *WellKnowns) GetOptionalBigInt() *wrappers.Int64Value {
	if m != nil {
		return m.OptionalBigInt
	}
	return nil
}

func (m *WellKnowns) GetListOBigInts() []*wrappers.Int64Value {
	if m != nil {
		return m.ListOBigInts
	}
	return nil
}

func (m *WellKnowns) GetSmallId() *wrappers.UInt32Value {
	if m != nil {
		return m.SmallId
	}
	return nil
}

func (m *WellKnowns) GetOptionalSmallId() *wrappers.UInt32Value {
	if m != nil {
		return m.OptionalSmallId
	}
	return nil
}

func (m *WellKnowns) GetListOSmallIds() []*wrappers.UInt32Value {
	if m != nil {
		return m.ListOSmallIds
	}
	return nil
}

func (m *WellKnowns) GetBigId() *wrappers.UInt64Value {
	if m != nil {
		return m.BigId
	}
	return nil
}

func (m *WellKnowns) GetOptionalBigId() *wrappers.UInt64Value {
	if m != nil {
		return m.OptionalBigId
	}
	return nil
}

func (m *WellKnowns) GetListOBigIds() []*wrappers.UInt64Value {
	if m != nil {
		return m.ListOBigIds
	}
	return nil
}

type NumbersNumbersNumbers struct {
	Usually_1            *int32   `protobuf:"varint,1,opt,name=usually_1,json=usually1,def=1" json:"usually_1,omitempty"`
	SomeNum_1            *int32   `protobuf:"varint,2,opt,name=some_num_1,json=someNum1" json:"some_num_1,omitempty"`
	NeededNum_1          *int32   `protobuf:"varint,3,req,name=needed_num_1,json=neededNum1" json:"needed_num_1,omitempty"`
	Usually_2            *int64   `protobuf:"varint,4,opt,name=usually_2,json=usually2,def=2" json:"usually_2,omitempty"`
	SomeNum_2            *int64   `protobuf:"varint,5,opt,name=some_num_2,json=someNum2" json:"some_num_2,omitempty"`
	NeededNum_2          *int64   `protobuf:"varint,6,req,name=needed_num_2,json=neededNum2" json:"needed_num_2,omitempty"`
	Usually_3            *uint32  `protobuf:"varint,7,opt,name=usually_3,json=usually3,def=3" json:"usually_3,omitempty"`
	SomeNum_3            *uint32  `protobuf:"varint,8,opt,name=some_num_3,json=someNum3" json:"some_num_3,omitempty"`
	NeededNum_3          *uint32  `protobuf:"varint,9,req,name=needed_num_3,json=neededNum3" json:"needed_num_3,omitempty"`
	Usually_4            *uint64  `protobuf:"varint,10,opt,name=usually_4,json=usually4,def=4" json:"usually_4,omitempty"`
	SomeNum_4            *uint64  `protobuf:"varint,11,opt,name=some_num_4,json=someNum4" json:"some_num_4,omitempty"`
	NeededNum_4          *uint64  `protobuf:"varint,12,req,name=needed_num_4,json=neededNum4" json:"needed_num_4,omitempty"`
	Usually_5            *int32   `protobuf:"zigzag32,13,opt,name=usually_5,json=usually5,def=5" json:"usually_5,omitempty"`
	SomeNum_5            *int32   `protobuf:"zigzag32,14,opt,name=some_num_5,json=someNum5" json:"some_num_5,omitempty"`
	NeededNum_5          *int32   `protobuf:"zigzag32,15,req,name=needed_num_5,json=neededNum5" json:"needed_num_5,omitempty"`
	Usually_6            *int64   `protobuf:"zigzag64,16,opt,name=usually_6,json=usually6,def=6" json:"usually_6,omitempty"`
	SomeNum_6            *int64   `protobuf:"zigzag64,17,opt,name=some_num_6,json=someNum6" json:"some_num_6,omitempty"`
	NeededNum_6          *int64   `protobuf:"zigzag64,18,req,name=needed_num_6,json=neededNum6" json:"needed_num_6,omitempty"`
	Usually_7            *uint32  `protobuf:"fixed32,19,opt,name=usually_7,json=usually7,def=7" json:"usually_7,omitempty"`
	SomeNum_7            *uint32  `protobuf:"fixed32,20,opt,name=some_num_7,json=someNum7" json:"some_num_7,omitempty"`
	NeededNum_7          *uint32  `protobuf:"fixed32,21,req,name=needed_num_7,json=neededNum7" json:"needed_num_7,omitempty"`
	Usually_8            *uint64  `protobuf:"fixed64,22,opt,name=usually_8,json=usually8,def=8" json:"usually_8,omitempty"`
	SomeNum_8            *uint64  `protobuf:"fixed64,23,opt,name=some_num_8,json=someNum8" json:"some_num_8,omitempty"`
	NeededNum_8          *uint64  `protobuf:"fixed64,24,req,name=needed_num_8,json=neededNum8" json:"needed_num_8,omitempty"`
	Usually_9            *int32   `protobuf:"fixed32,25,opt,name=usually_9,json=usually9,def=9" json:"usually_9,omitempty"`
	SomeNum_9            *int32   `protobuf:"fixed32,26,opt,name=some_num_9,json=someNum9" json:"some_num_9,omitempty"`
	NeededNum_9          *int32   `protobuf:"fixed32,27,req,name=needed_num_9,json=neededNum9" json:"needed_num_9,omitempty"`
	Usually_10           *int64   `protobuf:"fixed64,28,opt,name=usually_10,json=usually10,def=10" json:"usually_10,omitempty"`
	SomeNum_10           *int64   `protobuf:"fixed64,29,opt,name=some_num_10,json=someNum10" json:"some_num_10,omitempty"`
	NeededNum_10         *int64   `protobuf:"fixed64,30,req,name=needed_num_10,json=neededNum10" json:"needed_num_10,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NumbersNumbersNumbers proto.InternalMessageInfo

const Default_NumbersNumbersNumbers_Usually_1 int32 = 1
const Default_NumbersNumbersNumbers_Usually_2 int64 = 2
const Default_NumbersNumbersNumbers_Usually_3 uint32 = 3
const Default_NumbersNumbersNumbers_Usually_4 uint64 = 4
const Default_NumbersNumbersNumbers_Usually_5 int32 = 5
const Default_NumbersNumbersNumbers_Usually_6 int64 = 6
const Default_NumbersNumbersNumbers_Usually_7 uint32 = 7
const Default_NumbersNumbersNumbers_Usually_8 uint64 = 8
const Default_NumbersNumbersNumbers_Usually_9 int32 = 9
const Default_NumbersNumbersNumbers_Usually_10 int64 = 10

func (m *NumbersNumbersNumbers) GetUsually_1() int32 {
	if m != nil && m.Usually_1 != nil {
		return *m.Usually_1
	}
	return Default_NumbersNumbersNumbers_Usually_1
}

func (m *NumbersNumbersNumbers) GetSomeNum_1() int32 {
	if m != nil && m.SomeNum_1 != nil {
		return *m.SomeNum_1
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_1() int32 {
	if m != nil && m.NeededNum_1 != nil {
		return *m.NeededNum_1
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_2() int64 {
	if m != nil && m.Usually_2 != nil {
		return *m.Usually_2
	}
	return Default_NumbersNumbersNumbers_Usually_2
}

func (m *NumbersNumbersNumbers) GetSomeNum_2() int64 {
	if m != nil && m.SomeNum_2 != nil {
		return *m.SomeNum_2
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_2() int64 {
	if m != nil && m.NeededNum_2 != nil {
		return *m.NeededNum_2
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_3() uint32 {
	if m != nil && m.Usually_3 != nil {
		return *m.Usually_3
	}
	return Default_NumbersNumbersNumbers_Usually_3
}

func (m *NumbersNumbersNumbers) GetSomeNum_3() uint32 {
	if m != nil && m.SomeNum_3 != nil {
		return *m.SomeNum_3
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_3() uint32 {
	if m != nil && m.NeededNum_3 != nil {
		return *m.NeededNum_3
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_4() uint64 {
	if m != nil && m.Usually_4 != nil {
		return *m.Usually_4
	}
	return Default_NumbersNumbersNumbers_Usually_4
}

func (m *NumbersNumbersNumbers) GetSomeNum_4() uint64 {
	if m != nil && m.SomeNum_4 != nil {
		return *m.SomeNum_4
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_4() uint64 {
	if m != nil && m.NeededNum_4 != nil {
		return *m.NeededNum_4
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_5() int32 {
	if m != nil && m.Usually_5 != nil {
		return *m.Usually_5
	}
	return Default_NumbersNumbersNumbers_Usually_5
}

func (m *NumbersNumbersNumbers) GetSomeNum_5() int32 {
	if m != nil && m.SomeNum_5 != nil {
		return *m.SomeNum_5
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_5() int32 {
	if m != nil && m.NeededNum_5 != nil {
		return *m.NeededNum_5
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_6() int64 {
	if m != nil && m.Usually_6 != nil {
		return *m.Usually_6
	}
	return Default_NumbersNumbersNumbers_Usually_6
}

func (m *NumbersNumbersNumbers) GetSomeNum_6() int64 {
	if m != nil && m.SomeNum_6 != nil {
		return *m.SomeNum_6
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_6() int64 {
	if m != nil && m.NeededNum_6 != nil {
		return *m.NeededNum_6
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_7() uint32 {
	if m != nil && m.Usually_7 != nil {
		return *m.Usually_7
	}
	return Default_NumbersNumbersNumbers_Usually_7
}

func (m *NumbersNumbersNumbers) GetSomeNum_7() uint32 {
	if m != nil && m.SomeNum_7 != nil {
		return *m.SomeNum_7
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_7() uint32 {
	if m != nil && m.NeededNum_7 != nil {
		return *m.NeededNum_7
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_8() uint64 {
	if m != nil && m.Usually_8 != nil {
		return *m.Usually_8
	}
	return Default_NumbersNumbersNumbers_Usually_8
}

func (m *NumbersNumbersNumbers) GetSomeNum_8() uint64 {
	if m != nil && m.SomeNum_8 != nil {
		return *m.SomeNum_8
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_8() uint64 {
	if m != nil && m.NeededNum_8 != nil {
		return *m.NeededNum_8
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_9() int32 {
	if m != nil && m.Usually_9 != nil {
		return *m.Usually_9
	}
	return Default_NumbersNumbersNumbers_Usually_9
}

func (m *NumbersNumbersNumbers) GetSomeNum_9() int32 {
	if m != nil && m.SomeNum_9 != nil {
		return *m.SomeNum_9
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_9() int32 {
	if m != nil && m.NeededNum_9 != nil {
		return *m.NeededNum_9
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetUsually_10() int64 {
	if m != nil && m.Usually_10 != nil {
		return *m.Usually_10
	}
	return Default_NumbersNumbersNumbers_Usually_10
}

func (m *NumbersNumbersNumbers) GetSomeNum_10() int64 {
	if m != nil && m.SomeNum_10 != nil {
		return *m.SomeNum_10
	}
	return 0
}

func (m *NumbersNumbersNumbers) GetNeededNum_10() int64 {
	if m != nil && m.NeededNum_10 != nil {
		return *m.NeededNum_10
	}
	return 0
}

type Arrays struct {
	Names                []string  `protobuf:"bytes,1,rep,name=names" json:"names,omitempty"`
	Data                 [][]byte  `protobuf:"bytes,2,rep,name=data" json:"data,omitempty"`
	Relatives            []*Person `protobuf:"bytes,3,rep,name=relatives" json:"relatives,omitempty"`
	OtherStates          []State   `protobuf:"varint,14,rep,name=other_states,json=otherStates,enum=test.State" json:"other_states,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_Arrays proto.InternalMessageInfo

func (m *Arrays) GetNames() []string {
	if m != nil {
		return m.Names
	}
	return nil
}

func (m *Arrays) GetData() [][]byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *Arrays) GetRelatives() []*Person {
	if m != nil {
		return m.Relatives
	}
	return nil
}

func (m *Arrays) GetOtherStates() []State {
	if m != nil {
		return m.OtherStates
	}
	return nil
}

type Maps struct {
	StringSet            map[string]Void         `protobuf:"bytes,1,rep,name=string_set,json=stringSet" json:"string_set,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=test.Void"`
	Int32Set             map[int32]Void          `protobuf:"bytes,2,rep,name=int32_set,json=int32Set" json:"int32_set,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=test.Void"`
	Int64Set             map[int64]Void          `protobuf:"bytes,3,rep,name=int64_set,json=int64Set" json:"int64_set,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=test.Void"`
	Uint32Set            map[uint32]Void         `protobuf:"bytes,4,rep,name=uint32_set,json=uint32Set" json:"uint32_set,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=test.Void"`
	Uint64Set            map[uint64]Void         `protobuf:"bytes,5,rep,name=uint64_set,json=uint64Set" json:"uint64_set,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=test.Void"`
	Sint32Set            map[int32]Void          `protobuf:"bytes,6,rep,name=sint32_set,json=sint32Set" json:"sint32_set,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=test.Void"`
	Sint64Set            map[int64]Void          `protobuf:"bytes,7,rep,name=sint64_set,json=sint64Set" json:"sint64_set,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=test.Void"`
	Fixed32Set           map[uint32]*empty.Empty `protobuf:"bytes,8,rep,name=fixed32_set,json=fixed32Set" json:"fixed32_set,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	Fixed64Set           map[uint64]*empty.Empty `protobuf:"bytes,9,rep,name=fixed64_set,json=fixed64Set" json:"fixed64_set,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	Sfixed32Set          map[int32]*empty.Empty  `protobuf:"bytes,10,rep,name=sfixed32_set,json=sfixed32Set" json:"sfixed32_set,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	Sfixed64Set          map[int64]*empty.Empty  `protobuf:"bytes,11,rep,name=sfixed64_set,json=sfixed64Set" json:"sfixed64_set,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	PeopleByEmployeeNum  map[int32]*Person       `protobuf:"bytes,12,rep,name=people_by_employee_num,json=peopleByEmployeeNum" json:"people_by_employee_num,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	States               map[int32]State         `protobuf:"bytes,13,rep,name=states" json:"states,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=test.State"`
	StringNames          map[string]string       `protobuf:"bytes,14,rep,name=string_names,json=stringNames" json:"string_names,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	BytesNames           map[string][]byte       `protobuf:"bytes,15,rep,name=bytes_names,json=bytesNames" json:"bytes_names,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	BoolNames            map[string]bool         `protobuf:"bytes,16,rep,name=bool_names,json=boolNames" json:"bool_names,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	DoubleNames          map[string]float64      `protobuf:"bytes,17,rep,name=double_names,json=doubleNames" json:"double_names,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	FloatNames           map[string]float32      `protobuf:"bytes,18,rep,name=float_names,json=floatNames" json:"float_names,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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_cf54b8462ccc4096, []int{5}
}
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_Size() int {
	return xxx_messageInfo_Maps.Size(m)
}
func (m *Maps) XXX_DiscardUnknown() {
	xxx_messageInfo_Maps.DiscardUnknown(m)
}

var xxx_messageInfo_Maps proto.InternalMessageInfo

func (m *Maps) GetStringSet() map[string]Void {
	if m != nil {
		return m.StringSet
	}
	return nil
}

func (m *Maps) GetInt32Set() map[int32]Void {
	if m != nil {
		return m.Int32Set
	}
	return nil
}

func (m *Maps) GetInt64Set() map[int64]Void {
	if m != nil {
		return m.Int64Set
	}
	return nil
}

func (m *Maps) GetUint32Set() map[uint32]Void {
	if m != nil {
		return m.Uint32Set
	}
	return nil
}

func (m *Maps) GetUint64Set() map[uint64]Void {
	if m != nil {
		return m.Uint64Set
	}
	return nil
}

func (m *Maps) GetSint32Set() map[int32]Void {
	if m != nil {
		return m.Sint32Set
	}
	return nil
}

func (m *Maps) GetSint64Set() map[int64]Void {
	if m != nil {
		return m.Sint64Set
	}
	return nil
}

func (m *Maps) GetFixed32Set() map[uint32]*empty.Empty {
	if m != nil {
		return m.Fixed32Set
	}
	return nil
}

func (m *Maps) GetFixed64Set() map[uint64]*empty.Empty {
	if m != nil {
		return m.Fixed64Set
	}
	return nil
}

func (m *Maps) GetSfixed32Set() map[int32]*empty.Empty {
	if m != nil {
		return m.Sfixed32Set
	}
	return nil
}

func (m *Maps) GetSfixed64Set() map[int64]*empty.Empty {
	if m != nil {
		return m.Sfixed64Set
	}
	return nil
}

func (m *Maps) GetPeopleByEmployeeNum() map[int32]*Person {
	if m != nil {
		return m.PeopleByEmployeeNum
	}
	return nil
}

func (m *Maps) GetStates() map[int32]State {
	if m != nil {
		return m.States
	}
	return nil
}

func (m *Maps) GetStringNames() map[string]string {
	if m != nil {
		return m.StringNames
	}
	return nil
}

func (m *Maps) GetBytesNames() map[string][]byte {
	if m != nil {
		return m.BytesNames
	}
	return nil
}

func (m *Maps) GetBoolNames() map[string]bool {
	if m != nil {
		return m.BoolNames
	}
	return nil
}

func (m *Maps) GetDoubleNames() map[string]float64 {
	if m != nil {
		return m.DoubleNames
	}
	return nil
}

func (m *Maps) GetFloatNames() map[string]float32 {
	if m != nil {
		return m.FloatNames
	}
	return nil
}

type TestMessage struct {
	Recurse              *TestMessage           `protobuf:"bytes,2,opt,name=recurse" json:"recurse,omitempty"`
	RepeatedRecurse      []*TestMessage         `protobuf:"bytes,3,rep,name=repeated_recurse,json=repeatedRecurse" json:"repeated_recurse,omitempty"`
	Person               *Person                `protobuf:"bytes,4,req,name=person" json:"person,omitempty"`
	State                *State                 `protobuf:"varint,5,req,name=state,enum=test.State" json:"state,omitempty"`
	Numbers              *NumbersNumbersNumbers `protobuf:"bytes,6,opt,name=numbers" json:"numbers,omitempty"`
	Usually_4242         *float32               `protobuf:"fixed32,7,opt,name=usually_4242,json=usually4242,def=4242" json:"usually_4242,omitempty"`
	SomeNumA             *float32               `protobuf:"fixed32,8,opt,name=some_num_a,json=someNumA" json:"some_num_a,omitempty"`
	NeededNumA           *float32               `protobuf:"fixed32,9,req,name=needed_num_a,json=neededNumA" json:"needed_num_a,omitempty"`
	Usually_9999         *float64               `protobuf:"fixed64,10,opt,name=usually_9999,json=usually9999,def=9999" json:"usually_9999,omitempty"`
	SomeNumB             *float64               `protobuf:"fixed64,11,opt,name=some_num_b,json=someNumB" json:"some_num_b,omitempty"`
	NeededNumB           *float64               `protobuf:"fixed64,12,req,name=needed_num_b,json=neededNumB" json:"needed_num_b,omitempty"`
	NextState            *State                 `protobuf:"varint,13,opt,name=next_state,json=nextState,enum=test.State,def=2" json:"next_state,omitempty"`
	Base64Stuff          []byte                 `protobuf:"bytes,14,opt,name=base64_stuff,json=base64Stuff" json:"base64_stuff,omitempty"`
	OpaqueId             []byte                 `protobuf:"bytes,15,req,name=opaque_id,json=opaqueId" json:"opaque_id,omitempty"`
	Wk                   *WellKnowns            `protobuf:"bytes,16,opt,name=wk" json:"wk,omitempty"`
	Arrays               *Arrays                `protobuf:"bytes,17,opt,name=arrays" json:"arrays,omitempty"`
	Maps                 *Maps                  `protobuf:"bytes,18,opt,name=maps" json:"maps,omitempty"`
	Misc                 *TestMessage_Misc      `protobuf:"group,19,opt,name=Misc,json=misc" json:"misc,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

var xxx_messageInfo_TestMessage proto.InternalMessageInfo

const Default_TestMessage_Usually_4242 float32 = 4242
const Default_TestMessage_Usually_9999 float64 = 9999
const Default_TestMessage_NextState State = State_PENDING

func (m *TestMessage) GetRecurse() *TestMessage {
	if m != nil {
		return m.Recurse
	}
	return nil
}

func (m *TestMessage) GetRepeatedRecurse() []*TestMessage {
	if m != nil {
		return m.RepeatedRecurse
	}
	return nil
}

func (m *TestMessage) GetPerson() *Person {
	if m != nil {
		return m.Person
	}
	return nil
}

func (m *TestMessage) GetState() State {
	if m != nil && m.State != nil {
		return *m.State
	}
	return State_INVALID
}

func (m *TestMessage) GetNumbers() *NumbersNumbersNumbers {
	if m != nil {
		return m.Numbers
	}
	return nil
}

func (m *TestMessage) GetUsually_4242() float32 {
	if m != nil && m.Usually_4242 != nil {
		return *m.Usually_4242
	}
	return Default_TestMessage_Usually_4242
}

func (m *TestMessage) GetSomeNumA() float32 {
	if m != nil && m.SomeNumA != nil {
		return *m.SomeNumA
	}
	return 0
}

func (m *TestMessage) GetNeededNumA() float32 {
	if m != nil && m.NeededNumA != nil {
		return *m.NeededNumA
	}
	return 0
}

func (m *TestMessage) GetUsually_9999() float64 {
	if m != nil && m.Usually_9999 != nil {
		return *m.Usually_9999
	}
	return Default_TestMessage_Usually_9999
}

func (m *TestMessage) GetSomeNumB() float64 {
	if m != nil && m.SomeNumB != nil {
		return *m.SomeNumB
	}
	return 0
}

func (m *TestMessage) GetNeededNumB() float64 {
	if m != nil && m.NeededNumB != nil {
		return *m.NeededNumB
	}
	return 0
}

func (m *TestMessage) GetNextState() State {
	if m != nil && m.NextState != nil {
		return *m.NextState
	}
	return Default_TestMessage_NextState
}

func (m *TestMessage) GetBase64Stuff() []byte {
	if m != nil {
		return m.Base64Stuff
	}
	return nil
}

func (m *TestMessage) GetOpaqueId() []byte {
	if m != nil {
		return m.OpaqueId
	}
	return nil
}

func (m *TestMessage) GetWk() *WellKnowns {
	if m != nil {
		return m.Wk
	}
	return nil
}

func (m *TestMessage) GetArrays() *Arrays {
	if m != nil {
		return m.Arrays
	}
	return nil
}

func (m *TestMessage) GetMaps() *Maps {
	if m != nil {
		return m.Maps
	}
	return nil
}

func (m *TestMessage) GetMisc() *TestMessage_Misc {
	if m != nil {
		return m.Misc
	}
	return nil
}

type TestMessage_Misc struct {
	Foo                  *string  `protobuf:"bytes,1,opt,name=foo" json:"foo,omitempty"`
	Bar                  *int32   `protobuf:"varint,2,opt,name=bar" json:"bar,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TestMessage_Misc proto.InternalMessageInfo

func (m *TestMessage_Misc) GetFoo() string {
	if m != nil && m.Foo != nil {
		return *m.Foo
	}
	return ""
}

func (m *TestMessage_Misc) GetBar() int32 {
	if m != nil && m.Bar != nil {
		return *m.Bar
	}
	return 0
}

func init() {
	proto.RegisterType((*Person)(nil), "test.Person")
	proto.RegisterType((*Address)(nil), "test.Address")
	proto.RegisterType((*WellKnowns)(nil), "test.WellKnowns")
	proto.RegisterType((*NumbersNumbersNumbers)(nil), "test.NumbersNumbersNumbers")
	proto.RegisterType((*Arrays)(nil), "test.Arrays")
	proto.RegisterType((*Maps)(nil), "test.Maps")
	proto.RegisterMapType((map[string]bool)(nil), "test.Maps.BoolNamesEntry")
	proto.RegisterMapType((map[string][]byte)(nil), "test.Maps.BytesNamesEntry")
	proto.RegisterMapType((map[string]float64)(nil), "test.Maps.DoubleNamesEntry")
	proto.RegisterMapType((map[uint32]*empty.Empty)(nil), "test.Maps.Fixed32SetEntry")
	proto.RegisterMapType((map[uint64]*empty.Empty)(nil), "test.Maps.Fixed64SetEntry")
	proto.RegisterMapType((map[string]float32)(nil), "test.Maps.FloatNamesEntry")
	proto.RegisterMapType((map[int32]Void)(nil), "test.Maps.Int32SetEntry")
	proto.RegisterMapType((map[int64]Void)(nil), "test.Maps.Int64SetEntry")
	proto.RegisterMapType((map[int32]*Person)(nil), "test.Maps.PeopleByEmployeeNumEntry")
	proto.RegisterMapType((map[int32]*empty.Empty)(nil), "test.Maps.Sfixed32SetEntry")
	proto.RegisterMapType((map[int64]*empty.Empty)(nil), "test.Maps.Sfixed64SetEntry")
	proto.RegisterMapType((map[int32]Void)(nil), "test.Maps.Sint32SetEntry")
	proto.RegisterMapType((map[int64]Void)(nil), "test.Maps.Sint64SetEntry")
	proto.RegisterMapType((map[int32]State)(nil), "test.Maps.StatesEntry")
	proto.RegisterMapType((map[string]string)(nil), "test.Maps.StringNamesEntry")
	proto.RegisterMapType((map[string]Void)(nil), "test.Maps.StringSetEntry")
	proto.RegisterMapType((map[uint32]Void)(nil), "test.Maps.Uint32SetEntry")
	proto.RegisterMapType((map[uint64]Void)(nil), "test.Maps.Uint64SetEntry")
	proto.RegisterType((*TestMessage)(nil), "test.TestMessage")
	proto.RegisterType((*TestMessage_Misc)(nil), "test.TestMessage.Misc")
	proto.RegisterEnum("test.State", State_name, State_value)
	proto.RegisterEnum("test.Void", Void_name, Void_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

// KitchenSinkClient is the client API for KitchenSink service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type KitchenSinkClient interface {
	Ping(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error)
	Exchange(ctx context.Context, in *TestMessage, opts ...grpc.CallOption) (*TestMessage, error)
	UploadMany(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_UploadManyClient, error)
	DownloadMany(ctx context.Context, in *TestMessage, opts ...grpc.CallOption) (KitchenSink_DownloadManyClient, error)
	DoManyThings(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_DoManyThingsClient, error)
	SendTimestamp(ctx context.Context, in *timestamp.Timestamp, opts ...grpc.CallOption) (*empty.Empty, error)
	SendDuration(ctx context.Context, in *duration.Duration, opts ...grpc.CallOption) (*empty.Empty, error)
	SendAny(ctx context.Context, in *any.Any, opts ...grpc.CallOption) (*empty.Empty, error)
	SendStruct(ctx context.Context, in *_struct.Struct, opts ...grpc.CallOption) (*empty.Empty, error)
	SendValue(ctx context.Context, in *_struct.Value, opts ...grpc.CallOption) (*empty.Empty, error)
	SendListValue(ctx context.Context, in *_struct.ListValue, opts ...grpc.CallOption) (*empty.Empty, error)
	SendBytes(ctx context.Context, in *wrappers.BytesValue, opts ...grpc.CallOption) (*empty.Empty, error)
	SendString(ctx context.Context, in *wrappers.StringValue, opts ...grpc.CallOption) (*empty.Empty, error)
	SendBool(ctx context.Context, in *wrappers.BoolValue, opts ...grpc.CallOption) (*empty.Empty, error)
	SendDouble(ctx context.Context, in *wrappers.DoubleValue, opts ...grpc.CallOption) (*empty.Empty, error)
	SendFloat(ctx context.Context, in *wrappers.FloatValue, opts ...grpc.CallOption) (*empty.Empty, error)
	SendInt32(ctx context.Context, in *wrappers.Int32Value, opts ...grpc.CallOption) (*empty.Empty, error)
	SendInt64(ctx context.Context, in *wrappers.Int64Value, opts ...grpc.CallOption) (*empty.Empty, error)
	SendUInt32(ctx context.Context, in *wrappers.UInt32Value, opts ...grpc.CallOption) (*empty.Empty, error)
	SendUInt64(ctx context.Context, in *wrappers.UInt64Value, opts ...grpc.CallOption) (*empty.Empty, error)
	SendMultipleTimestamp(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleTimestampClient, error)
	SendMultipleDuration(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleDurationClient, error)
	SendMultipleAny(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleAnyClient, error)
	SendMultipleStruct(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleStructClient, error)
	SendMultipleValue(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleValueClient, error)
	SendMultipleListValue(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleListValueClient, error)
	SendMultipleBytes(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleBytesClient, error)
	SendMultipleString(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleStringClient, error)
	SendMultipleBool(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleBoolClient, error)
	SendMultipleDouble(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleDoubleClient, error)
	SendMultipleFloat(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleFloatClient, error)
	SendMultipleInt32(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleInt32Client, error)
	SendMultipleInt64(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleInt64Client, error)
	SendMultipleUInt32(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleUInt32Client, error)
	SendMultipleUInt64(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleUInt64Client, error)
}

type kitchenSinkClient struct {
	cc *grpc.ClientConn
}

func NewKitchenSinkClient(cc *grpc.ClientConn) KitchenSinkClient {
	return &kitchenSinkClient{cc}
}

func (c *kitchenSinkClient) Ping(ctx context.Context, in *empty.Empty, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/Ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) Exchange(ctx context.Context, in *TestMessage, opts ...grpc.CallOption) (*TestMessage, error) {
	out := new(TestMessage)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/Exchange", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) UploadMany(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_UploadManyClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[0], "/test.KitchenSink/UploadMany", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkUploadManyClient{stream}
	return x, nil
}

type KitchenSink_UploadManyClient interface {
	Send(*TestMessage) error
	CloseAndRecv() (*TestMessage, error)
	grpc.ClientStream
}

type kitchenSinkUploadManyClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkUploadManyClient) Send(m *TestMessage) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) DownloadMany(ctx context.Context, in *TestMessage, opts ...grpc.CallOption) (KitchenSink_DownloadManyClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[1], "/test.KitchenSink/DownloadMany", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkDownloadManyClient{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 KitchenSink_DownloadManyClient interface {
	Recv() (*TestMessage, error)
	grpc.ClientStream
}

type kitchenSinkDownloadManyClient struct {
	grpc.ClientStream
}

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

func (c *kitchenSinkClient) DoManyThings(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_DoManyThingsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[2], "/test.KitchenSink/DoManyThings", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkDoManyThingsClient{stream}
	return x, nil
}

type KitchenSink_DoManyThingsClient interface {
	Send(*TestMessage) error
	Recv() (*TestMessage, error)
	grpc.ClientStream
}

type kitchenSinkDoManyThingsClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkDoManyThingsClient) Send(m *TestMessage) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendTimestamp(ctx context.Context, in *timestamp.Timestamp, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendTimestamp", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendDuration(ctx context.Context, in *duration.Duration, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendDuration", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendAny(ctx context.Context, in *any.Any, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendAny", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendStruct(ctx context.Context, in *_struct.Struct, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendStruct", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendValue(ctx context.Context, in *_struct.Value, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendValue", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendListValue(ctx context.Context, in *_struct.ListValue, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendListValue", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendBytes(ctx context.Context, in *wrappers.BytesValue, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendBytes", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendString(ctx context.Context, in *wrappers.StringValue, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendString", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendBool(ctx context.Context, in *wrappers.BoolValue, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendBool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendDouble(ctx context.Context, in *wrappers.DoubleValue, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendDouble", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendFloat(ctx context.Context, in *wrappers.FloatValue, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendFloat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendInt32(ctx context.Context, in *wrappers.Int32Value, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendInt32", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendInt64(ctx context.Context, in *wrappers.Int64Value, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendInt64", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendUInt32(ctx context.Context, in *wrappers.UInt32Value, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendUInt32", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendUInt64(ctx context.Context, in *wrappers.UInt64Value, opts ...grpc.CallOption) (*empty.Empty, error) {
	out := new(empty.Empty)
	err := c.cc.Invoke(ctx, "/test.KitchenSink/SendUInt64", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *kitchenSinkClient) SendMultipleTimestamp(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleTimestampClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[3], "/test.KitchenSink/SendMultipleTimestamp", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleTimestampClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleTimestampClient interface {
	Send(*timestamp.Timestamp) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleTimestampClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleTimestampClient) Send(m *timestamp.Timestamp) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleDuration(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleDurationClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[4], "/test.KitchenSink/SendMultipleDuration", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleDurationClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleDurationClient interface {
	Send(*duration.Duration) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleDurationClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleDurationClient) Send(m *duration.Duration) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleAny(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleAnyClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[5], "/test.KitchenSink/SendMultipleAny", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleAnyClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleAnyClient interface {
	Send(*any.Any) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleAnyClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleAnyClient) Send(m *any.Any) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleStruct(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleStructClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[6], "/test.KitchenSink/SendMultipleStruct", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleStructClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleStructClient interface {
	Send(*_struct.Struct) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleStructClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleStructClient) Send(m *_struct.Struct) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleValue(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleValueClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[7], "/test.KitchenSink/SendMultipleValue", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleValueClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleValueClient interface {
	Send(*_struct.Value) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleValueClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleValueClient) Send(m *_struct.Value) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleListValue(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleListValueClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[8], "/test.KitchenSink/SendMultipleListValue", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleListValueClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleListValueClient interface {
	Send(*_struct.ListValue) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleListValueClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleListValueClient) Send(m *_struct.ListValue) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleBytes(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleBytesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[9], "/test.KitchenSink/SendMultipleBytes", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleBytesClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleBytesClient interface {
	Send(*wrappers.BytesValue) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleBytesClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleBytesClient) Send(m *wrappers.BytesValue) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleString(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleStringClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[10], "/test.KitchenSink/SendMultipleString", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleStringClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleStringClient interface {
	Send(*wrappers.StringValue) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleStringClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleStringClient) Send(m *wrappers.StringValue) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleBool(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleBoolClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[11], "/test.KitchenSink/SendMultipleBool", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleBoolClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleBoolClient interface {
	Send(*wrappers.BoolValue) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleBoolClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleBoolClient) Send(m *wrappers.BoolValue) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleDouble(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleDoubleClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[12], "/test.KitchenSink/SendMultipleDouble", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleDoubleClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleDoubleClient interface {
	Send(*wrappers.DoubleValue) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleDoubleClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleDoubleClient) Send(m *wrappers.DoubleValue) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleFloat(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleFloatClient, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[13], "/test.KitchenSink/SendMultipleFloat", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleFloatClient{stream}
	return x, nil
}

type KitchenSink_SendMultipleFloatClient interface {
	Send(*wrappers.FloatValue) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleFloatClient struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleFloatClient) Send(m *wrappers.FloatValue) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleInt32(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleInt32Client, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[14], "/test.KitchenSink/SendMultipleInt32", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleInt32Client{stream}
	return x, nil
}

type KitchenSink_SendMultipleInt32Client interface {
	Send(*wrappers.Int32Value) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleInt32Client struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleInt32Client) Send(m *wrappers.Int32Value) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleInt64(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleInt64Client, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[15], "/test.KitchenSink/SendMultipleInt64", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleInt64Client{stream}
	return x, nil
}

type KitchenSink_SendMultipleInt64Client interface {
	Send(*wrappers.Int64Value) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleInt64Client struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleInt64Client) Send(m *wrappers.Int64Value) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleUInt32(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleUInt32Client, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[16], "/test.KitchenSink/SendMultipleUInt32", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleUInt32Client{stream}
	return x, nil
}

type KitchenSink_SendMultipleUInt32Client interface {
	Send(*wrappers.UInt32Value) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleUInt32Client struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleUInt32Client) Send(m *wrappers.UInt32Value) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *kitchenSinkClient) SendMultipleUInt64(ctx context.Context, opts ...grpc.CallOption) (KitchenSink_SendMultipleUInt64Client, error) {
	stream, err := c.cc.NewStream(ctx, &_KitchenSink_serviceDesc.Streams[17], "/test.KitchenSink/SendMultipleUInt64", opts...)
	if err != nil {
		return nil, err
	}
	x := &kitchenSinkSendMultipleUInt64Client{stream}
	return x, nil
}

type KitchenSink_SendMultipleUInt64Client interface {
	Send(*wrappers.UInt64Value) error
	CloseAndRecv() (*empty.Empty, error)
	grpc.ClientStream
}

type kitchenSinkSendMultipleUInt64Client struct {
	grpc.ClientStream
}

func (x *kitchenSinkSendMultipleUInt64Client) Send(m *wrappers.UInt64Value) error {
	return x.ClientStream.SendMsg(m)
}

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

// KitchenSinkServer is the server API for KitchenSink service.
type KitchenSinkServer interface {
	Ping(context.Context, *empty.Empty) (*empty.Empty, error)
	Exchange(context.Context, *TestMessage) (*TestMessage, error)
	UploadMany(KitchenSink_UploadManyServer) error
	DownloadMany(*TestMessage, KitchenSink_DownloadManyServer) error
	DoManyThings(KitchenSink_DoManyThingsServer) error
	SendTimestamp(context.Context, *timestamp.Timestamp) (*empty.Empty, error)
	SendDuration(context.Context, *duration.Duration) (*empty.Empty, error)
	SendAny(context.Context, *any.Any) (*empty.Empty, error)
	SendStruct(context.Context, *_struct.Struct) (*empty.Empty, error)
	SendValue(context.Context, *_struct.Value) (*empty.Empty, error)
	SendListValue(context.Context, *_struct.ListValue) (*empty.Empty, error)
	SendBytes(context.Context, *wrappers.BytesValue) (*empty.Empty, error)
	SendString(context.Context, *wrappers.StringValue) (*empty.Empty, error)
	SendBool(context.Context, *wrappers.BoolValue) (*empty.Empty, error)
	SendDouble(context.Context, *wrappers.DoubleValue) (*empty.Empty, error)
	SendFloat(context.Context, *wrappers.FloatValue) (*empty.Empty, error)
	SendInt32(context.Context, *wrappers.Int32Value) (*empty.Empty, error)
	SendInt64(context.Context, *wrappers.Int64Value) (*empty.Empty, error)
	SendUInt32(context.Context, *wrappers.UInt32Value) (*empty.Empty, error)
	SendUInt64(context.Context, *wrappers.UInt64Value) (*empty.Empty, error)
	SendMultipleTimestamp(KitchenSink_SendMultipleTimestampServer) error
	SendMultipleDuration(KitchenSink_SendMultipleDurationServer) error
	SendMultipleAny(KitchenSink_SendMultipleAnyServer) error
	SendMultipleStruct(KitchenSink_SendMultipleStructServer) error
	SendMultipleValue(KitchenSink_SendMultipleValueServer) error
	SendMultipleListValue(KitchenSink_SendMultipleListValueServer) error
	SendMultipleBytes(KitchenSink_SendMultipleBytesServer) error
	SendMultipleString(KitchenSink_SendMultipleStringServer) error
	SendMultipleBool(KitchenSink_SendMultipleBoolServer) error
	SendMultipleDouble(KitchenSink_SendMultipleDoubleServer) error
	SendMultipleFloat(KitchenSink_SendMultipleFloatServer) error
	SendMultipleInt32(KitchenSink_SendMultipleInt32Server) error
	SendMultipleInt64(KitchenSink_SendMultipleInt64Server) error
	SendMultipleUInt32(KitchenSink_SendMultipleUInt32Server) error
	SendMultipleUInt64(KitchenSink_SendMultipleUInt64Server) error
}

func RegisterKitchenSinkServer(s *grpc.Server, srv KitchenSinkServer) {
	s.RegisterService(&_KitchenSink_serviceDesc, srv)
}

func _KitchenSink_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(empty.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/Ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).Ping(ctx, req.(*empty.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_Exchange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).Exchange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/Exchange",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).Exchange(ctx, req.(*TestMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_UploadMany_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).UploadMany(&kitchenSinkUploadManyServer{stream})
}

type KitchenSink_UploadManyServer interface {
	SendAndClose(*TestMessage) error
	Recv() (*TestMessage, error)
	grpc.ServerStream
}

type kitchenSinkUploadManyServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkUploadManyServer) SendAndClose(m *TestMessage) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_DownloadMany_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(TestMessage)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(KitchenSinkServer).DownloadMany(m, &kitchenSinkDownloadManyServer{stream})
}

type KitchenSink_DownloadManyServer interface {
	Send(*TestMessage) error
	grpc.ServerStream
}

type kitchenSinkDownloadManyServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkDownloadManyServer) Send(m *TestMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _KitchenSink_DoManyThings_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).DoManyThings(&kitchenSinkDoManyThingsServer{stream})
}

type KitchenSink_DoManyThingsServer interface {
	Send(*TestMessage) error
	Recv() (*TestMessage, error)
	grpc.ServerStream
}

type kitchenSinkDoManyThingsServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkDoManyThingsServer) Send(m *TestMessage) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendTimestamp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(timestamp.Timestamp)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendTimestamp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendTimestamp",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendTimestamp(ctx, req.(*timestamp.Timestamp))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendDuration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(duration.Duration)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendDuration(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendDuration",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendDuration(ctx, req.(*duration.Duration))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendAny_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(any.Any)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendAny(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendAny",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendAny(ctx, req.(*any.Any))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendStruct_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(_struct.Struct)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendStruct(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendStruct",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendStruct(ctx, req.(*_struct.Struct))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(_struct.Value)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendValue(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendValue",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendValue(ctx, req.(*_struct.Value))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendListValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(_struct.ListValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendListValue(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendListValue",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendListValue(ctx, req.(*_struct.ListValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendBytes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.BytesValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendBytes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendBytes",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendBytes(ctx, req.(*wrappers.BytesValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendString_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.StringValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendString(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendString",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendString(ctx, req.(*wrappers.StringValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendBool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.BoolValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendBool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendBool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendBool(ctx, req.(*wrappers.BoolValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendDouble_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.DoubleValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendDouble(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendDouble",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendDouble(ctx, req.(*wrappers.DoubleValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendFloat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.FloatValue)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendFloat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendFloat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendFloat(ctx, req.(*wrappers.FloatValue))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendInt32_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.Int32Value)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendInt32(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendInt32",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendInt32(ctx, req.(*wrappers.Int32Value))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendInt64_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.Int64Value)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendInt64(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendInt64",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendInt64(ctx, req.(*wrappers.Int64Value))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendUInt32_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.UInt32Value)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendUInt32(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendUInt32",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendUInt32(ctx, req.(*wrappers.UInt32Value))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendUInt64_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(wrappers.UInt64Value)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KitchenSinkServer).SendUInt64(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/test.KitchenSink/SendUInt64",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KitchenSinkServer).SendUInt64(ctx, req.(*wrappers.UInt64Value))
	}
	return interceptor(ctx, in, info, handler)
}

func _KitchenSink_SendMultipleTimestamp_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleTimestamp(&kitchenSinkSendMultipleTimestampServer{stream})
}

type KitchenSink_SendMultipleTimestampServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*timestamp.Timestamp, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleTimestampServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleTimestampServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleDuration_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleDuration(&kitchenSinkSendMultipleDurationServer{stream})
}

type KitchenSink_SendMultipleDurationServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*duration.Duration, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleDurationServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleDurationServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleAny_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleAny(&kitchenSinkSendMultipleAnyServer{stream})
}

type KitchenSink_SendMultipleAnyServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*any.Any, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleAnyServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleAnyServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleStruct_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleStruct(&kitchenSinkSendMultipleStructServer{stream})
}

type KitchenSink_SendMultipleStructServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*_struct.Struct, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleStructServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleStructServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleValue_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleValue(&kitchenSinkSendMultipleValueServer{stream})
}

type KitchenSink_SendMultipleValueServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*_struct.Value, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleValueServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleValueServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleListValue_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleListValue(&kitchenSinkSendMultipleListValueServer{stream})
}

type KitchenSink_SendMultipleListValueServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*_struct.ListValue, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleListValueServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleListValueServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleBytes_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleBytes(&kitchenSinkSendMultipleBytesServer{stream})
}

type KitchenSink_SendMultipleBytesServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.BytesValue, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleBytesServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleBytesServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleString_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleString(&kitchenSinkSendMultipleStringServer{stream})
}

type KitchenSink_SendMultipleStringServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.StringValue, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleStringServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleStringServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleBool_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleBool(&kitchenSinkSendMultipleBoolServer{stream})
}

type KitchenSink_SendMultipleBoolServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.BoolValue, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleBoolServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleBoolServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleDouble_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleDouble(&kitchenSinkSendMultipleDoubleServer{stream})
}

type KitchenSink_SendMultipleDoubleServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.DoubleValue, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleDoubleServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleDoubleServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleFloat_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleFloat(&kitchenSinkSendMultipleFloatServer{stream})
}

type KitchenSink_SendMultipleFloatServer interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.FloatValue, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleFloatServer struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleFloatServer) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleInt32_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleInt32(&kitchenSinkSendMultipleInt32Server{stream})
}

type KitchenSink_SendMultipleInt32Server interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.Int32Value, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleInt32Server struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleInt32Server) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleInt64_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleInt64(&kitchenSinkSendMultipleInt64Server{stream})
}

type KitchenSink_SendMultipleInt64Server interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.Int64Value, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleInt64Server struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleInt64Server) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleUInt32_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleUInt32(&kitchenSinkSendMultipleUInt32Server{stream})
}

type KitchenSink_SendMultipleUInt32Server interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.UInt32Value, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleUInt32Server struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleUInt32Server) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

func _KitchenSink_SendMultipleUInt64_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(KitchenSinkServer).SendMultipleUInt64(&kitchenSinkSendMultipleUInt64Server{stream})
}

type KitchenSink_SendMultipleUInt64Server interface {
	SendAndClose(*empty.Empty) error
	Recv() (*wrappers.UInt64Value, error)
	grpc.ServerStream
}

type kitchenSinkSendMultipleUInt64Server struct {
	grpc.ServerStream
}

func (x *kitchenSinkSendMultipleUInt64Server) SendAndClose(m *empty.Empty) error {
	return x.ServerStream.SendMsg(m)
}

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

var _KitchenSink_serviceDesc = grpc.ServiceDesc{
	ServiceName: "test.KitchenSink",
	HandlerType: (*KitchenSinkServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Ping",
			Handler:    _KitchenSink_Ping_Handler,
		},
		{
			MethodName: "Exchange",
			Handler:    _KitchenSink_Exchange_Handler,
		},
		{
			MethodName: "SendTimestamp",
			Handler:    _KitchenSink_SendTimestamp_Handler,
		},
		{
			MethodName: "SendDuration",
			Handler:    _KitchenSink_SendDuration_Handler,
		},
		{
			MethodName: "SendAny",
			Handler:    _KitchenSink_SendAny_Handler,
		},
		{
			MethodName: "SendStruct",
			Handler:    _KitchenSink_SendStruct_Handler,
		},
		{
			MethodName: "SendValue",
			Handler:    _KitchenSink_SendValue_Handler,
		},
		{
			MethodName: "SendListValue",
			Handler:    _KitchenSink_SendListValue_Handler,
		},
		{
			MethodName: "SendBytes",
			Handler:    _KitchenSink_SendBytes_Handler,
		},
		{
			MethodName: "SendString",
			Handler:    _KitchenSink_SendString_Handler,
		},
		{
			MethodName: "SendBool",
			Handler:    _KitchenSink_SendBool_Handler,
		},
		{
			MethodName: "SendDouble",
			Handler:    _KitchenSink_SendDouble_Handler,
		},
		{
			MethodName: "SendFloat",
			Handler:    _KitchenSink_SendFloat_Handler,
		},
		{
			MethodName: "SendInt32",
			Handler:    _KitchenSink_SendInt32_Handler,
		},
		{
			MethodName: "SendInt64",
			Handler:    _KitchenSink_SendInt64_Handler,
		},
		{
			MethodName: "SendUInt32",
			Handler:    _KitchenSink_SendUInt32_Handler,
		},
		{
			MethodName: "SendUInt64",
			Handler:    _KitchenSink_SendUInt64_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "UploadMany",
			Handler:       _KitchenSink_UploadMany_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "DownloadMany",
			Handler:       _KitchenSink_DownloadMany_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DoManyThings",
			Handler:       _KitchenSink_DoManyThings_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleTimestamp",
			Handler:       _KitchenSink_SendMultipleTimestamp_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleDuration",
			Handler:       _KitchenSink_SendMultipleDuration_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleAny",
			Handler:       _KitchenSink_SendMultipleAny_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleStruct",
			Handler:       _KitchenSink_SendMultipleStruct_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleValue",
			Handler:       _KitchenSink_SendMultipleValue_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleListValue",
			Handler:       _KitchenSink_SendMultipleListValue_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleBytes",
			Handler:       _KitchenSink_SendMultipleBytes_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleString",
			Handler:       _KitchenSink_SendMultipleString_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleBool",
			Handler:       _KitchenSink_SendMultipleBool_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleDouble",
			Handler:       _KitchenSink_SendMultipleDouble_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleFloat",
			Handler:       _KitchenSink_SendMultipleFloat_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleInt32",
			Handler:       _KitchenSink_SendMultipleInt32_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleInt64",
			Handler:       _KitchenSink_SendMultipleInt64_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleUInt32",
			Handler:       _KitchenSink_SendMultipleUInt32_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "SendMultipleUInt64",
			Handler:       _KitchenSink_SendMultipleUInt64_Handler,
			ClientStreams: true,
		},
	},
	Metadata: "test.proto",
}

func init() { proto.RegisterFile("test.proto", fileDescriptor_test_cf54b8462ccc4096) }

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