text:
package examplepb

import (
	context "context"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
)

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

type GetValueRequest struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_GetValueRequest proto.InternalMessageInfo

func (m *GetValueRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

type GetValueResponse struct {
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_GetValueResponse proto.InternalMessageInfo

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

type SetValueRequest struct {
	Key   string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_SetValueRequest proto.InternalMessageInfo

func (m *SetValueRequest) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

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

type SetValueResponse struct {
}

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

var xxx_messageInfo_SetValueResponse proto.InternalMessageInfo

type EchoOutRequest struct {
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_EchoOutRequest proto.InternalMessageInfo

func (m *EchoOutRequest) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type EchoOutResponse struct {
	AllMessages []string `protobuf:"bytes,2,rep,name=all_messages,json=allMessages,proto3" json:"all_messages,omitempty"`
}

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

var xxx_messageInfo_EchoOutResponse proto.InternalMessageInfo

func (m *EchoOutResponse) GetAllMessages() []string {
	if m != nil {
		return m.AllMessages
	}
	return nil
}

type EchoInRequest struct {
	Message      string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	NumResponses int64  `protobuf:"varint,2,opt,name=num_responses,json=numResponses,proto3" json:"num_responses,omitempty"`
}

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

var xxx_messageInfo_EchoInRequest proto.InternalMessageInfo

func (m *EchoInRequest) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *EchoInRequest) GetNumResponses() int64 {
	if m != nil {
		return m.NumResponses
	}
	return 0
}

type EchoInResponse struct {
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}

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

var xxx_messageInfo_EchoInResponse proto.InternalMessageInfo

func (m *EchoInResponse) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type EchoBothRequest struct {
	Message      string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	NumResponses int64  `protobuf:"varint,2,opt,name=num_responses,json=numResponses,proto3" json:"num_responses,omitempty"`
}

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

var xxx_messageInfo_EchoBothRequest proto.InternalMessageInfo

func (m *EchoBothRequest) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *EchoBothRequest) GetNumResponses() int64 {
	if m != nil {
		return m.NumResponses
	}
	return 0
}

type EchoBothResponse struct {
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}

func (m *EchoBothResponse) Reset()      { *m = EchoBothResponse{} }
func (*EchoBothResponse) ProtoMessage() {}
func (*EchoBothResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_43929dec9f67b739, []int{9}
}
func (m *EchoBothResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EchoBothResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EchoBothResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EchoBothResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EchoBothResponse.Merge(m, src)
}
func (m *EchoBothResponse) XXX_Size() int {
	return m.Size()
}
func (m *EchoBothResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_EchoBothResponse.DiscardUnknown(m)
}

var xxx_messageInfo_EchoBothResponse proto.InternalMessageInfo

func (m *EchoBothResponse) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func init() {
	proto.RegisterType((*GetValueRequest)(nil), "uber.yarpc.internal.examples.protobuf.example.GetValueRequest")
	proto.RegisterType((*GetValueResponse)(nil), "uber.yarpc.internal.examples.protobuf.example.GetValueResponse")
	proto.RegisterType((*SetValueRequest)(nil), "uber.yarpc.internal.examples.protobuf.example.SetValueRequest")
	proto.RegisterType((*SetValueResponse)(nil), "uber.yarpc.internal.examples.protobuf.example.SetValueResponse")
	proto.RegisterType((*EchoOutRequest)(nil), "uber.yarpc.internal.examples.protobuf.example.EchoOutRequest")
	proto.RegisterType((*EchoOutResponse)(nil), "uber.yarpc.internal.examples.protobuf.example.EchoOutResponse")
	proto.RegisterType((*EchoInRequest)(nil), "uber.yarpc.internal.examples.protobuf.example.EchoInRequest")
	proto.RegisterType((*EchoInResponse)(nil), "uber.yarpc.internal.examples.protobuf.example.EchoInResponse")
	proto.RegisterType((*EchoBothRequest)(nil), "uber.yarpc.internal.examples.protobuf.example.EchoBothRequest")
	proto.RegisterType((*EchoBothResponse)(nil), "uber.yarpc.internal.examples.protobuf.example.EchoBothResponse")
}

func init() {
	proto.RegisterFile("internal/examples/protobuf/examplepb/example.proto", fileDescriptor_43929dec9f67b739)
}

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

func (this *GetValueRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

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

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

	that1, ok := that.(*EchoOutResponse)
	if !ok {
		that2, ok := that.(EchoOutResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.AllMessages) != len(that1.AllMessages) {
		return false
	}
	for i := range this.AllMessages {
		if this.AllMessages[i] != that1.AllMessages[i] {
			return false
		}
	}
	return true
}
func (this *EchoInRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

	that1, ok := that.(*EchoBothResponse)
	if !ok {
		that2, ok := that.(EchoBothResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	return true
}
func (this *GetValueRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&examplepb.GetValueRequest{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetValueResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&examplepb.GetValueResponse{")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SetValueRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&examplepb.SetValueRequest{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "Value: "+fmt.Sprintf("%#v", this.Value)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *SetValueResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 4)
	s = append(s, "&examplepb.SetValueResponse{")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EchoOutRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&examplepb.EchoOutRequest{")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EchoOutResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&examplepb.EchoOutResponse{")
	s = append(s, "AllMessages: "+fmt.Sprintf("%#v", this.AllMessages)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EchoInRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&examplepb.EchoInRequest{")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "NumResponses: "+fmt.Sprintf("%#v", this.NumResponses)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EchoInResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&examplepb.EchoInResponse{")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EchoBothRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&examplepb.EchoBothRequest{")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "NumResponses: "+fmt.Sprintf("%#v", this.NumResponses)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *EchoBothResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&examplepb.EchoBothResponse{")
	s = append(s, "Message: "+fmt.Sprintf("%#v", this.Message)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringExample(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// KeyValueClient is the client API for KeyValue service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type KeyValueClient interface {
	GetValue(ctx context.Context, in *GetValueRequest, opts ...grpc.CallOption) (*GetValueResponse, error)
	SetValue(ctx context.Context, in *SetValueRequest, opts ...grpc.CallOption) (*SetValueResponse, error)
}

type keyValueClient struct {
	cc *grpc.ClientConn
}

func NewKeyValueClient(cc *grpc.ClientConn) KeyValueClient {
	return &keyValueClient{cc}
}

func (c *keyValueClient) GetValue(ctx context.Context, in *GetValueRequest, opts ...grpc.CallOption) (*GetValueResponse, error) {
	out := new(GetValueResponse)
	err := c.cc.Invoke(ctx, "/uber.yarpc.internal.examples.protobuf.example.KeyValue/GetValue", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *keyValueClient) SetValue(ctx context.Context, in *SetValueRequest, opts ...grpc.CallOption) (*SetValueResponse, error) {
	out := new(SetValueResponse)
	err := c.cc.Invoke(ctx, "/uber.yarpc.internal.examples.protobuf.example.KeyValue/SetValue", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// KeyValueServer is the server API for KeyValue service.
type KeyValueServer interface {
	GetValue(context.Context, *GetValueRequest) (*GetValueResponse, error)
	SetValue(context.Context, *SetValueRequest) (*SetValueResponse, error)
}

// UnimplementedKeyValueServer can be embedded to have forward compatible implementations.
type UnimplementedKeyValueServer struct {
}

func (*UnimplementedKeyValueServer) GetValue(ctx context.Context, req *GetValueRequest) (*GetValueResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetValue not implemented")
}
func (*UnimplementedKeyValueServer) SetValue(ctx context.Context, req *SetValueRequest) (*SetValueResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetValue not implemented")
}

func RegisterKeyValueServer(s *grpc.Server, srv KeyValueServer) {
	s.RegisterService(&_KeyValue_serviceDesc, srv)
}

func _KeyValue_GetValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetValueRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeyValueServer).GetValue(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/uber.yarpc.internal.examples.protobuf.example.KeyValue/GetValue",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeyValueServer).GetValue(ctx, req.(*GetValueRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _KeyValue_SetValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetValueRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(KeyValueServer).SetValue(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/uber.yarpc.internal.examples.protobuf.example.KeyValue/SetValue",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(KeyValueServer).SetValue(ctx, req.(*SetValueRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _KeyValue_serviceDesc = grpc.ServiceDesc{
	ServiceName: "uber.yarpc.internal.examples.protobuf.example.KeyValue",
	HandlerType: (*KeyValueServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetValue",
			Handler:    _KeyValue_GetValue_Handler,
		},
		{
			MethodName: "SetValue",
			Handler:    _KeyValue_SetValue_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "internal/examples/protobuf/examplepb/example.proto",
}

// FooClient is the client API for Foo service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type FooClient interface {
	EchoOut(ctx context.Context, opts ...grpc.CallOption) (Foo_EchoOutClient, error)
	EchoIn(ctx context.Context, in *EchoInRequest, opts ...grpc.CallOption) (Foo_EchoInClient, error)
	EchoBoth(ctx context.Context, opts ...grpc.CallOption) (Foo_EchoBothClient, error)
}

type fooClient struct {
	cc *grpc.ClientConn
}

func NewFooClient(cc *grpc.ClientConn) FooClient {
	return &fooClient{cc}
}

func (c *fooClient) EchoOut(ctx context.Context, opts ...grpc.CallOption) (Foo_EchoOutClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Foo_serviceDesc.Streams[0], "/uber.yarpc.internal.examples.protobuf.example.Foo/EchoOut", opts...)
	if err != nil {
		return nil, err
	}
	x := &fooEchoOutClient{stream}
	return x, nil
}

type Foo_EchoOutClient interface {
	Send(*EchoOutRequest) error
	CloseAndRecv() (*EchoOutResponse, error)
	grpc.ClientStream
}

type fooEchoOutClient struct {
	grpc.ClientStream
}

func (x *fooEchoOutClient) Send(m *EchoOutRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *fooClient) EchoIn(ctx context.Context, in *EchoInRequest, opts ...grpc.CallOption) (Foo_EchoInClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Foo_serviceDesc.Streams[1], "/uber.yarpc.internal.examples.protobuf.example.Foo/EchoIn", opts...)
	if err != nil {
		return nil, err
	}
	x := &fooEchoInClient{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 Foo_EchoInClient interface {
	Recv() (*EchoInResponse, error)
	grpc.ClientStream
}

type fooEchoInClient struct {
	grpc.ClientStream
}

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

func (c *fooClient) EchoBoth(ctx context.Context, opts ...grpc.CallOption) (Foo_EchoBothClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Foo_serviceDesc.Streams[2], "/uber.yarpc.internal.examples.protobuf.example.Foo/EchoBoth", opts...)
	if err != nil {
		return nil, err
	}
	x := &fooEchoBothClient{stream}
	return x, nil
}

type Foo_EchoBothClient interface {
	Send(*EchoBothRequest) error
	Recv() (*EchoBothResponse, error)
	grpc.ClientStream
}

type fooEchoBothClient struct {
	grpc.ClientStream
}

func (x *fooEchoBothClient) Send(m *EchoBothRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

// FooServer is the server API for Foo service.
type FooServer interface {
	EchoOut(Foo_EchoOutServer) error
	EchoIn(*EchoInRequest, Foo_EchoInServer) error
	EchoBoth(Foo_EchoBothServer) error
}

// UnimplementedFooServer can be embedded to have forward compatible implementations.
type UnimplementedFooServer struct {
}

func (*UnimplementedFooServer) EchoOut(srv Foo_EchoOutServer) error {
	return status.Errorf(codes.Unimplemented, "method EchoOut not implemented")
}
func (*UnimplementedFooServer) EchoIn(req *EchoInRequest, srv Foo_EchoInServer) error {
	return status.Errorf(codes.Unimplemented, "method EchoIn not implemented")
}
func (*UnimplementedFooServer) EchoBoth(srv Foo_EchoBothServer) error {
	return status.Errorf(codes.Unimplemented, "method EchoBoth not implemented")
}

func RegisterFooServer(s *grpc.Server, srv FooServer) {
	s.RegisterService(&_Foo_serviceDesc, srv)
}

func _Foo_EchoOut_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(FooServer).EchoOut(&fooEchoOutServer{stream})
}

type Foo_EchoOutServer interface {
	SendAndClose(*EchoOutResponse) error
	Recv() (*EchoOutRequest, error)
	grpc.ServerStream
}

type fooEchoOutServer struct {
	grpc.ServerStream
}

func (x *fooEchoOutServer) SendAndClose(m *EchoOutResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

func _Foo_EchoIn_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(EchoInRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(FooServer).EchoIn(m, &fooEchoInServer{stream})
}

type Foo_EchoInServer interface {
	Send(*EchoInResponse) error
	grpc.ServerStream
}

type fooEchoInServer struct {
	grpc.ServerStream
}

func (x *fooEchoInServer) Send(m *EchoInResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Foo_EchoBoth_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(FooServer).EchoBoth(&fooEchoBothServer{stream})
}

type Foo_EchoBothServer interface {
	Send(*EchoBothResponse) error
	Recv() (*EchoBothRequest, error)
	grpc.ServerStream
}

type fooEchoBothServer struct {
	grpc.ServerStream
}

func (x *fooEchoBothServer) Send(m *EchoBothResponse) error {
	return x.ServerStream.SendMsg(m)
}

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

var _Foo_serviceDesc = grpc.ServiceDesc{
	ServiceName: "uber.yarpc.internal.examples.protobuf.example.Foo",
	HandlerType: (*FooServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "EchoOut",
			Handler:       _Foo_EchoOut_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "EchoIn",
			Handler:       _Foo_EchoIn_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "EchoBoth",
			Handler:       _Foo_EchoBoth_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "internal/examples/protobuf/examplepb/example.proto",
}

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

func (m *GetValueRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GetValueResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetValueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

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

func (m *SetValueRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetValueRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SetValueResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SetValueResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *EchoOutRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EchoOutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EchoOutResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EchoOutResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AllMessages) > 0 {
		for iNdEx := len(m.AllMessages) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.AllMessages[iNdEx])
			copy(dAtA[i:], m.AllMessages[iNdEx])
			i = encodeVarintExample(dAtA, i, uint64(len(m.AllMessages[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *EchoInRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EchoInRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumResponses != 0 {
		i = encodeVarintExample(dAtA, i, uint64(m.NumResponses))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EchoInResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EchoInResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EchoBothRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EchoBothRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumResponses != 0 {
		i = encodeVarintExample(dAtA, i, uint64(m.NumResponses))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EchoBothResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EchoBothResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintExample(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintExample(dAtA []byte, offset int, v uint64) int {
	offset -= sovExample(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GetValueRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	return n
}

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

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

func (m *SetValueResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *EchoOutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	return n
}

func (m *EchoOutResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.AllMessages) > 0 {
		for _, s := range m.AllMessages {
			l = len(s)
			n += 1 + l + sovExample(uint64(l))
		}
	}
	return n
}

func (m *EchoInRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if m.NumResponses != 0 {
		n += 1 + sovExample(uint64(m.NumResponses))
	}
	return n
}

func (m *EchoInResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	return n
}

func (m *EchoBothRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	if m.NumResponses != 0 {
		n += 1 + sovExample(uint64(m.NumResponses))
	}
	return n
}

func (m *EchoBothResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovExample(uint64(l))
	}
	return n
}

func sovExample(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozExample(x uint64) (n int) {
	return sovExample(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *GetValueRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetValueRequest{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetValueResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetValueResponse{`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SetValueRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SetValueRequest{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *SetValueResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&SetValueResponse{`,
		`}`,
	}, "")
	return s
}
func (this *EchoOutRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EchoOutRequest{`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EchoOutResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EchoOutResponse{`,
		`AllMessages:` + fmt.Sprintf("%v", this.AllMessages) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EchoInRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EchoInRequest{`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`NumResponses:` + fmt.Sprintf("%v", this.NumResponses) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EchoInResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EchoInResponse{`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EchoBothRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EchoBothRequest{`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`NumResponses:` + fmt.Sprintf("%v", this.NumResponses) + `,`,
		`}`,
	}, "")
	return s
}
func (this *EchoBothResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&EchoBothResponse{`,
		`Message:` + fmt.Sprintf("%v", this.Message) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringExample(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *GetValueRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExample
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetValueRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetValueRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExample
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthExample
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExample
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExample(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExample
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

var (
	ErrInvalidLengthExample        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowExample          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupExample = fmt.Errorf("proto: unexpected end of group")
)

redpajama_set_name: RedPajamaGithub


Curds and Wine is your Experience - Education - Entertainment headquarters for all of your winemaking and cheese making needs! We'll guide you in choosing the best yeasts for your fermentations, as well as other ingredients to make the best wines from your grapes. We also have equipment for rent to crush and press your wines. We do some basic in-house wine chemistry testing, but for more in-depth analysis our friends at Vinmetrica offer a wider array of tests. See our red wine making summary and basic shopping list available online to help you find everything you need for your fermentations.
In association with San Diego Amateur Winemakers' Society, Curds and Wine will be hosting bi-monthly home winemakers' seminars. These seminars are held every even numbered month on the third weekendat 1 pm. Seminars are given by Lum Eisenman, a winemaking guru that we are lucky to have in the San Diego area. Lum will share his expertise on various winemaking techniques and issues. This month, just in time for harvest season, Lum will discuss "Must Adjustments".
We are here to help you get some fresh grapes for your home winemaking this harvest season! We will once again be a pick-up point for fresh grapes from West Coast Grapes, grape varietal availability and pricing for 2014 will be online soon -- sign up to get notified when it is available.
Grapes are purchased directly through West Coast Grapes, we are a pick-up point only, no sales on site for these grapes! Please note, we cannot store these grapes, they will start spontaneously fermenting if you do not pick them up the day they arrive. We are anticipating a late September delivery; if you order grapes online from West Coast Grapes they will send you an email when the exact delivery date is set, or check our Facebook page for updates.
Harvest time is approaching -- time to get your crushpad ready! Curds and Wine has a limited selection of large equipment for sale this year, including manual or motorized crusher/destemmers and stands (sold separately), basket or bladder presses, and stainless steel tanks. We also have a few 3-spout and 5-spout gravity bottle fillers.
Keep your summer sips perfectly chilled with the Host Freeze Cooling Wine Glasses. Pop them in the freezer to keep your whites cool for hours, or store them in the refrigerator to keep your reds at perfect serving temperature - hot red wine is not so hot! These glasses are great, perfect for summer sipping at the grill or chillin' at the pool. Get yours today from Curds and Wine!
Contact us if you are looking for grapes for sale. We typically get information as grapes are ready to harvest, you might only have a few days notice. Often you will pick your own, and don't forget to check if they have a crusher/destemmer or if you will need to rent one from us. If you need to rent one from us please contact us as soon as you know your harvest date -- the crusher is very popular during harvest season and availability is not guaranteed without a reservation. We also of course have all of your harvest supplies and yeasts available a well as other equipment rentals, such as pumps and presses.
Cider House Select is a complete ingredient kit with everything* you need to craft the best cider. These 6 gallon recipes are deliciously packed full of flavor and perfect for any level of experience. Whether you're looking for an ice cold, refreshing drink during the hot summer months or looking to warm up during the cooler autumn and winter, Cider House Select ciders are a perfect choice for anytime of the year. With eight mouth-watering flavors to choose from you will have no problem finding one that's perfect for you!
See all of our cider kits available online.
*If you would like to make any of the Cider House Select ciders on site at Curds and Wine, you will need to bring 2 pounds of sugar the day you start your cider. Munton's cider kits require no additional ingredients. Contact us to make an appointment to start your cider kits with us!


text:
Q: jQuery FullCalendar, view month one more week is showing up I'm using the plug in FullCalendar in a month view (default one),
And when the month is printed it's showing one more week each time.
Let me know if you want more details or screenshots
    $('#calendar_expanded').fullCalendar({
        defaultView: "month",
        firstDay: $('#inputUserStartWeek').val(),
        height: $(window).height()-100
    });

A: Try setting weekMode to liquid or variable:
http://arshaw.com/fullcalendar/docs/display/weekMode/

redpajama_set_name: RedPajamaStackExchange


The Texas Business Centers Company*Business page was created many years ago. The last admin back in February **** held onto the admin rights and will not transfer them. I can prove that I am the current owner of this company. I had to go through this with other social media accounts, and ran into NO PROBLEMS regaining access, except Facebook. I would like to recover it and actually use it for my business, which actually includes spending money.
GetHuman2040643 did not yet indicate what Facebook should do to make this right.
We are waiting for GetHuman2040643 to fix the problem and share the solution with the rest of us customers.
GetHuman2040643 indicated the issue is not fixed yet.


26 Posture set series in 100 degrees. Be prepared to sweat, smile and cry tears of joy! Re-shape your body and mind in 60 minutes. We LOVE the absolute beginner! Bring an open mind and your happy, smiling face.
A dynamic dance of grace, athleticism and spirit - this uplifting hour of strengthening Vinyasa flow will rinse your body, and bring some clarity back into your day. Through a blend of core work, power holds, and arm balances you will improve endurance while re-aligning body and mind. An emphasis on breath work and focus takes you deeper, allowing for a meditative practice overall. All levels welcome.
Combines Flows with holding bikram poses.


text:
Q: c# - xml Edit attribute in child element I have the following xml file
<date-changer>
  <setting default="">
    <name content="first.exe"></name>
    <path content="firstFolderPath"></path>
    <date content="dateNow"></date>
  </setting>
  <setting default="">
    <name content="second.exe"></name>
    <path content="secondFolderPath"></path>
    <date content="dateNow"></date>
  </setting>
</date-changer>

And code to populate the xml
XmlDocument settXML = new XmlDocument();
            if (!File.Exists("settings.xml"))
            {
                XmlDeclaration XMLdec = settXML.CreateXmlDeclaration("1.0", null, null);
                settXML.AppendChild(XMLdec);
                XmlElement XMLRoot = settXML.CreateElement("date-changer");
                settXML.AppendChild(XMLRoot);

                XmlElement setting = settXML.CreateElement("setting");
                XMLRoot.AppendChild(setting);
                setting.SetAttribute("default", "");

                XmlElement name = settXML.CreateElement("name");
                setting.AppendChild(name);
                name.SetAttribute("content", nameTxt.Text);
                name.InnerText = nameTxt.Text;

                XmlElement path = settXML.CreateElement("path");
                setting.AppendChild(path);
                path.SetAttribute("content", fileLocTxt.Text);
                path.InnerText = fileLocTxt.Text;

                XmlElement date = settXML.CreateElement("date");
                setting.AppendChild(date);
                date.SetAttribute("content", dateTimePicker1.Value.Date.ToString("MM - dd - yyyy"));
                date.InnerText = dateTimePicker1.Value.Date.ToString("MM - dd - yyyy");

                settXML.Save("settings.xml");
                consoleLog.AppendText("Saved " + "'" + nameTxt.Text + "'");
                consoleLog.AppendText(Environment.NewLine);

                savesBox.Items.Add(nameTxt.Text);
            }
            else
            {
                settXML.Load("settings.xml");

                string xName = "date-changer/setting/name[@content='{0}']";
                string nameAttr = nameTxt.Text;

                string xPath = "date-changer/setting/path[@content='{0}']";
                string pathAttr = fileLocTxt.Text;

                string xDate = "date-changer/setting/date[@content='{0}']";
                string dateAttr = dateTimePicker1.Value.Date.ToString("MM - dd - yyyy");

                xName = String.Format(xName, nameAttr);
                XmlNode nameNode = settXML.SelectSingleNode(xName);

                xPath = String.Format(xPath, pathAttr);
                XmlNode pathNode = settXML.SelectSingleNode(xPath);

                xDate = String.Format(xDate, dateAttr);
                XmlNode dateNode = settXML.SelectSingleNode(xDate);

                if (nameNode != null)
                {
                    consoleLog.AppendText("Found File");
                    consoleLog.AppendText(Environment.NewLine);
                    pathNode.Attributes["content"].Value = fileLocTxt.Text;
                    settXML.Save("settings.xml");
                }
                else
                {
                    XmlElement setting = settXML.CreateElement("setting");
                    setting.SetAttribute("default", "");

                    XmlElement name = settXML.CreateElement("name");
                    setting.AppendChild(name);
                    name.SetAttribute("content", nameTxt.Text);
                    name.InnerText = nameTxt.Text;

                    XmlElement path = settXML.CreateElement("path");
                    setting.AppendChild(path);
                    path.SetAttribute("content", fileLocTxt.Text);
                    path.InnerText = fileLocTxt.Text;

                    XmlElement date = settXML.CreateElement("date");
                    setting.AppendChild(date);
                    date.SetAttribute("content", dateTimePicker1.Value.Date.ToString("MM - dd - yyyy"));
                    date.InnerText = dateTimePicker1.Value.Date.ToString("MM - dd - yyyy");

                    settXML.DocumentElement.AppendChild(setting);
                    settXML.Save("settings.xml");
                    consoleLog.AppendText("Saved " + "'" + nameTxt.Text + "'");
                    consoleLog.AppendText(Environment.NewLine);

                    savesBox.Items.Add(nameTxt.Text);
                }
            }

But I get Object reference not set to an instance of an object. at
if (nameNode != null)
{
 consoleLog.AppendText("Found File");
 consoleLog.AppendText(Environment.NewLine);
 pathNode.Attributes["content"].Value = fileLocTxt.Text;
 settXML.Save("settings.xml");
}

when I edit fileLocTxt.Text and save the xml file.
What I want to do is edit the path element attribute under name element if fileLocTxt.Text changed, but only if nameTxt.text is the same as the name element attribute. Hope that makes sense.
ex.
if (nameNode.Attributes["content"].Value == nameTxt.Text)
{
 if (pathNode.Attributes["content"].Value != fileLocTxt.Text)
 {
  pathNode.Attributes["content"].Value = fileLocTxt.Text;
 }
}


text:
Teams working on these models must understand, organize and provide a quantitative construct for signaling pathways, cellular and organ-level functions, and whole body outcomes along with myriad controlling and feedback mechanisms co-functioning to maintain a system's sentience.
Once completed though, researchers can conduct question-based investigations to guide decision making around target identification, proof of mechanism and concept, dose and regimen, patient enrollment, biomarkers, study design,and many other key questions in drug development and clinical therapeutics. These questions can be explored by including genetic variants, disease mechanisms, therapeutic and other interventions within a systems modeling framework.
When that research is complete and a QSP model is fit-for purpose, should the model be shared as part of an Open Science effort? After all, how can developer(s) afford to make results and content freely and openly available?
Let's argue instead that developers cannot afford to miss the opportunity afforded by Open Science. Failure to openly disclose and make content available only stunts the growth of our advancing community. Maintaining a "(not) my model" stance severely limits the impact and credibility of our work and all subsequent contributions to more wide-ranging research and science.
On October 7, 2017, please join Dr. Matthew Riggs, Chief Science Officer of Metrum Research Group LLC (MetrumRG), as he presents the open science position during the Quantitative Systems Pharmacology Symposium at the University at Buffalo South Campus.
In An Open Pitch for Open Science in QSP: Advocating By Example he'll provide a rationale for open science as a means of making QSP model development more efficient, accessible, reproducible, and credible. It is argued that an important side effect of this philosophy is wider acceptance and utilization, given that open models are more visible, may be peer-evaluated, and are better understood by a broader scientific and clinical base. Examples, including platforms for sharing models and open-source tools to explore these models, will be reviewed as evidence supporting open QSP (oQSP).
As a supporter of open science and oQSP, MetrumRG is driven by the goals of improving health and defeating disease, particularly where there are unmet needs.
Additional details for the October QSP Symposium in Buffalo are available online at: http://pharmacy.buffalo.edu/symposium2017

redpajama_set_name: RedPajamaCommonCrawl


With our expert staff we can offer world leading testing of thermal conductivity, diffusivity and specific heat capacity using the Hot Disk method. Our testing follows ISO 22007-2 and with the many years of experience the measurements are thorough and accurate.
We can test most materials being solids, powders, liquids, foams, gels or laminates. Required geometries are decided based on sample type and expected properties. Contact us and we'll find the best solution for your case. We are proud to be able to verify that our instrument are suitable to analyse your sample and to help you determine optimum testing parameters for successful testing in your own laboratory.


…and what have you done? Quite a bit actually, looking back over the year. Our Rob Orchard has recently cast his eye over the past 12 months to put together our usual annual review. To see what stood out the most for Rob in 2014 check out your latest issue of B&CB (issue 1308, 26 December 2014). It always makes for good reading, not only giving a view of what has been, but hinting at and ruminating over what might be in store next year. After all, we cannot know where we're going if we don't know where we've been.
Rob is not the only one that's been busy. Our very own Stuart Jones has been hard at it too, not least in his capacity as part of the judging panel of the International Bus & Coach of the Year, with the accolade this year going to the MAN Lion's City G CNG. Let's not forget new girl Kirsty either, who has done a sterling job of bringing you even more news and features. As always, a well deserved thank you goes out to all our contributors over the past 12 months too.
Looking back myself I was fortunate enough to have kept busy with various visits across the country, bringing you details of not only the latest news and developments but also some of the companies out there supporting your operations. Thank you to everyone that welcomed me and extended their friendship over the past 12 months. It makes me realise what a welcoming and people orientated industry we are all a part of.
Merry Christmas and a happy New Year to all our readers from Stuart, Chris, Andy, Sallyanne, Kirsty, Katie, Rob, John and Danny.


IN the shadow of oil spills, fluorocarbons, and toxic waste, the phosphate-in-detergent issue is small. But small concerns can make a big difference. If you live in a state that doesn't already ban phosphates in laundry detergent, ``you can help to make an immediate difference in water quality by not buying phosphate-based detergent,'' says John Kabler, Chesapeake Bay Area director for Clean Water Action in Baltimore.
No federal action has been taken on a phosphate ban, because each situation is different, says Richard Sedlak, research director of the Soap and Detergent Association: ``The extent to which phosphates are a problem is very localized.'' Detergent phosphate accounts for only 3 percent of all phosphorous emissions overall in the United States, he says, but in some highly populated areas detergent phosphorous is a much more significant percentage.
The first bans on phosphate detergent occurred in the Great Lakes region in the 1970s, when Lake Erie, in particular, was choked with pollution. Other states followed suit, the most recent being Pennsylvania in July.
Detergents have never had a positive image environmentally. One of the first widely noted ecological crises in this country was the foaming streams, rivers, and lakes of the 1950s and early '60s. The soap industry had to reformulate detergents to remove nonbiodegradable chemicals.
Today, ``all [laundry detergent] products that are marketed are biodegradable,'' says Mr. Sedlak.
Phosphates became an issue in the '60s. When phosphate, a plant nutrient, enters a body of water, algae feed on it. Too much phosphate causes algae to grow too fast. When the algae die, two problems are created: Dead algae cloud the water, blocking sunlight. As the algae decompose they use up oxygen, sometimes killing fish.
Mr. Kabler, a veteran of the ``phosphate wars,'' says that this process, called accelerated eutrophication, is a problem in many parts of the country. Phosphate from laundry detergent is just one contributor, he says.
But why have phosphate in detergent at all?
Consumer demand, says Sedlak. Phosphate is a ``marvelous performer,'' softening water and making detergent clean better and more cheaply.
In the '70s, nonphosphate detergents were a flop. Frustrated consumers used more detergent, washed loads twice, or - most alarming to manufacturers - switched to other brands, says Sedlak. Today's powdered nonphosphate detergents (liquid detergents have never had phosphates) are much better, but still are not up to par, he says. Detergents with phosphate yield better performance per dollar spent, he says, which is another reason consumers still rate phosphates high.
Gregory Good, a consultant at Klein & Co., a private consulting company in Fairfield, NJ, says consumers are not that concerned about the link between detergent and environment. ``Is it [the decision to buy] really environmental - which one works better? Or is it the double coupon? I would say it's the latter,'' says Mr. Good.
``Nobody knew when phosphates were taken out of their detergents,'' says Charles Fox, legislative director of Friends of the Earth, an environmental watchdog organization. ``The average consumer isn't going to know any difference.'' He shares the view of many environmentalists that keeping phosphate in detergents is unnecessary and shortsighted.
``It's a tremendous, politically charged issue involving the chemical industry, detergent industry, and, in some cases, the unions,'' he says. His organization supports a nationwide ban.
Jesse Lynn, development director of laundry detergent for Lever Brothers (Wisk, Surf, All), says manufacturers keep phosphate in powder detergents because it ``aids manufacturing and cleaning, and is cost effective.'' The position of the detergent industry is that sewage treatment is the most effective way to deal with phosphate, says Dr. Lynn.
Phosphate bans have had a remarkable effect in cleaning up he Chesapeake Bay, say environmentalists. The effect of bans has been ``greater than environmentalists ever thought it would be, both in terms of economics and water quality,'' says Clean Water Action's Kabler. Savings to Maryland sewage-treatment plants exceeds $4.4 million per year in chemicals and cartage for phosphate treatment, he says.


Video editing has a notorious learning curve and is generally not very beginner-friendly. If you've tried to use an editor in the past, you may have been put off by how complicated it was.
That won't be the case with Movavi Video Editor, as it was developed specifically to provide a more user-friendly alternative without any learning curve to speak of.
Overall the user experience of Movavi Video Editor is smooth and intuitive. Its interface is timeline-based and has a clean design that uses icons and tabs to organize its tools and features. Because of this approach, it is easy to navigate and find what you are looking for.
Similarly, Movavi Video Editor has engineered each tool and feature to try to make it as intuitive as possible. To do that it leverages actions that are common and familiar, such as dragging and dropping elements, adjusting sliders, resizing frames, and so on.
Suffice to say it won't take long for you to familiarize yourself with Movavi Video Editor's interface or features – and it should be a smooth and painless experience. Regardless of whether you're a beginner or more experienced user you should be able to acclimatize yourself with the editor quickly.
Split videos into segments to isolate and trim out any unwanted parts.
Merge video clips and arrange them in the order that is required.
Enhance the video quality manually or automatically and fix other issues that may be present.
Add audio tracks to videos to include background music or a voiceover.
Edit audio tracks to improve the sound quality, adjust audio levels, or apply audio effects.
Apply artistic filters to give the video a unique visual style.
Utilize special effects such as Chroma Key, fast forward, split screen, and more.
Insert customizable text elements as captions, titles, or subtitles, including some in animated styles.
As you can see you'll have a lot of powerful options that you can choose from to edit your videos.
To sum it up Movavi Video Editor does live up to its aim of providing a more user-friendly and intuitive option to edit videos. At the same time, it does not scale back on features to do so and remains a potent video editor.
If you're looking for a way to start to compile, improve and create video content – you can't go wrong by trying it out. Even more, experienced users will probably find its simple and streamlined approach to be a breath of fresh air and it will allow them to make the changes that they want more quickly and effectively.


text:
← Alive for Game 5
Series Over →
Got it to Game 6
Oh, here we go.
The Philadelphia 76ers had a 3-0 series lead against the Toronto Raptors. They started talking about a sweep. No one really gave the Raptors a chance to get back in the series. And rightfully so. No one in NBA history has ever come back to win a series after going down 3-0.
I had come to accept the fact that the Raptors season was going end soon.
But something changed.
I think if history were ever to be made, we have the two perfect ingredients to make it happen. We have the 76ers, who have players and a coach who are known for having a hard time closing out series. Add to that their inherent "front-runner" mentality and knack for pointing the finger when things go wrong.
Pair that with the Toronto Raptors. A team that has faced more adversity over the last few years than fans outside of Canada probably realize. They are a team that never gives up; one that always finds a way to win.
I remember one of Nick Nurse's mantras in his first year coaching the team was, "There are 1000 ways to win a basketball game, we just have to find 1 of them."
And you can see in the way that he coaches, and the way this team plays, that they are constantly searching for what works. They don't stop until they find it.
I think the Raptors have found their winning formula. Game 5, for the lack of a better term, was a cake walk. The 76ers could've closed out the series at home, in front of their fans, and basked in confetti and adoration.
Instead, it looked like they forgot to show up. They looked like they didn't want to compete. Did they all stay up late playing video games? The Raptors controlled every single moment of the game.
With the Raptors up 12 with 4 minutes remaining, the fans started to leave. They were going home! Oh, they were also booing. They started doing that early on.
As if the pressure wasn't already mounting, the home fans were starting to turn on their own team. I loved it.
The consensus after that game was there was no way the 76ers were going to go to Toronto and win Game 7. Absolutely no way.
I believe that, too.
Toronto has been the better team for the last three games. They should've won Game 3. The fact that the 76ers snuck out that win is the only reason why they aren't facing elimination tonight.
This series has turned.
The Raptors are doing to the 76ers exactly what I thought they would do before Game 1. Minimize Joel Embiid and James Harden, and dare "the others" to beat you. That's finally happening.
Embiid looked exhausted in Game 5. The Raptors blew by him, six possessions in a row. He averaged 33.8 minutes-per-game in the regular season and is now being asked to play close to 40 in the playoffs. On top of that, the Raptors are making sure that he can't just camp out in the lane on defence and recover some stamina. They are making him move.
Going back a few games, I made a mental note to myself that the 76ers substitution pattern for Embiid is not that helpful to them. They have him playing the entire 1st and 3rd quarters, and then sitting for the first 3-4 minutes of the 2nd and 4th quarters.
When he's out of the game, all the Raptors should do is attack the basket. Paul Reed isn't stopping anybody. They've turned Georges Niang into a turnstile. No one is protecting the rim.
It's only when the 76ers bench has taken on too much water, that they're forced to bring Embiid back in the game.
It's easy for me to say, but why not take him for the last 90 seconds of the 1st quarter. Let him get rest during the TV timeout at the end of the quarter which is about 3.5 minutes, and then give him another 90 seconds on the bench at the start of the 2nd quarter. At which point, he'd be 3.5 minutes away from the next mandatory TV timeout.
I just think that's a better plan for him, but if the 76ers want to keep him on the bench for a 4-minute stretch to start quarters, I'm going to let them keep doing it.
Meanwhile, the Raptors starters have been playing heavy minutes all year. Earlier in the season, Nick Nurse and Masai Ujiri addressed it with the media. They said that our young players need to learn how to play a lot of minutes because that's how it's going to be in the playoffs.
Well, weren't they smart. The Raptors look like they were made for this.
James Harden has not looked like James Harden, at all. He had one more point (15) than Danny Green in Game 5. God love Danny Green, but the Raptors will take this every day of the week.
So, let's recap. The 76ers bench has been rendered useless. Tyrese Maxey has come back down to earth. James Harden is not James Harden. Danny Green is okay, but nothing to be afraid of. Embiid is exhausted. And Tobias Harris has been good.
Oh, and Embiid has his thumb injury. I almost forgot.
I said in my last post that when you have torn ligaments in your finger, you're very aware of the situations you place that finger in. Embiid admitted as much to the media. What I took away from his comments was that he's not putting himself in situations where his thumb will get hit.
That is fine with me because for the first two games of the series, he was running through our entire defence. If he wants to avoid contact now, go for it.
I think tonight's game could be a blowout in the Raptors favour. We still haven't had a good shooting game from three-point range. Maybe that comes tonight.
However, I am wary that Raptors fans (myself included) are getting a bit too confident. I think that's okay, as long as the team doesn't feel overconfident, but we need to be mindful of not blowing up the balloon so much that it pops. We need to let the 76ers implode, without bailing them out because we got complacent.
This is a trap game. We're looking ahead to Game 7, as if it's a certainty, but we still have to beat a very good NBA team to get there.
Yesterday, Doc Rivers felt the need to defend his checkered past of blowing 3-1 leads. After Game 5, Embiid was saying that Harden needs to be more aggressive, which is just so rich and comical. I mean, it's true, but the fact that he said it about Ben Simmons last year and is now saying it about one of the best scorers in NBA history, is just amazing.
I think they are spiralling.
The Raptors need to step on their throats tonight. Get a big lead and just let the fans pile it on the 76ers bench.
I'm expecting a "Raps in 7" chant, at some point tonight.
Forget the fact that this series was at 3-0, for just a second. If you told me the Raptors would be down 3-2 in the series (without saying how we got to this point) and they had a chance to force a Game 7 by winning Game 6 at home – I would've taken it in a heartbeat.
Just win this game.
We got it to Game 6.
We need to get it to Game 7.
This entry was posted in Sports and tagged Canada, Fandom, NBA Playoffs, Opinion, Philadelphia 76ers, Reflection, Thoughts, Toronto Raptors. Bookmark the permalink.
5 Responses to Got it to Game 6
littlewhitepearls says:
I was hoping for a better game 7 but i think they ran out of gas – we definitely need to add to the roster to get this team some help
It was a disappointing end to the series for sure. You're right, the team needs help in a lot of places. I'm confident they'd have a better team next year.
I'm hoping they add the pieces needed in the off season 🤞🏻🤞🏻
Dutch Lion says:
Interesting how that turned out. I laughed when you mentioned the 76ers were up too late playing video games. My last roommate before I got married was my best friend and we would stay up really late playing Madden 2000. I kept winning and he would make me play again and again. I sometimes had to lose on purpose just so he would let me get some sleep before waking up early for work. Your comment made me relive some old memories. Thanks!
I would do the same thing with my roommates. Late hours playing video games. One time I kept beating a friend at NHL and eventually he just slammed down the controller and went to his room. We laugh about it now.