eager_service.pb.go

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

package tensorflow

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	io "io"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type RemoteTensorHandle struct {
	// The ID of the operation that produced this tensor.
	OpId int64 `protobuf:"varint,1,opt,name=op_id,json=opId,proto3" json:"op_id,omitempty"`
	// The index into the outputs of the operation that produced this tensor.
	OutputNum int32 `protobuf:"varint,2,opt,name=output_num,json=outputNum,proto3" json:"output_num,omitempty"`
}

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

var xxx_messageInfo_RemoteTensorHandle proto.InternalMessageInfo

func (m *RemoteTensorHandle) GetOpId() int64 {
	if m != nil {
		return m.OpId
	}
	return 0
}

func (m *RemoteTensorHandle) GetOutputNum() int32 {
	if m != nil {
		return m.OutputNum
	}
	return 0
}

// A proto representation of an eager operation.
type Operation struct {
	// A unique identifier for the operation. Set by the client so that the client
	// can uniquely identify the outputs of the scheduled operation.
	//
	// In the initial implementation, sending duplicate IDs has undefined
	// behaviour, but additional constraints may be placed upon this in the
	// future.
	Id     int64                 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Name   string                `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Inputs []*RemoteTensorHandle `protobuf:"bytes,3,rep,name=inputs,proto3" json:"inputs,omitempty"`
	// Control Operation IDs that will be respected when ops are re-ordered by
	// async execution. If async execution (+ op re-ordering) is not enabled, this
	// should have no effect.
	ControlOpIds []int64               `protobuf:"varint,4,rep,packed,name=control_op_ids,json=controlOpIds,proto3" json:"control_op_ids,omitempty"`
	Attrs        map[string]*AttrValue `protobuf:"bytes,5,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Device       string                `protobuf:"bytes,6,opt,name=device,proto3" json:"device,omitempty"`
}

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

var xxx_messageInfo_Operation proto.InternalMessageInfo

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

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

func (m *Operation) GetInputs() []*RemoteTensorHandle {
	if m != nil {
		return m.Inputs
	}
	return nil
}

func (m *Operation) GetControlOpIds() []int64 {
	if m != nil {
		return m.ControlOpIds
	}
	return nil
}

func (m *Operation) GetAttrs() map[string]*AttrValue {
	if m != nil {
		return m.Attrs
	}
	return nil
}

func (m *Operation) GetDevice() string {
	if m != nil {
		return m.Device
	}
	return ""
}

type QueueItem struct {
	// The remote executor should be able to handle either executing ops directly,
	// or releasing any unused tensor handles, since the tensor lifetime is
	// maintained by the client.
	//
	// Types that are valid to be assigned to Item:
	//	*QueueItem_HandleToDecref
	//	*QueueItem_Operation
	Item isQueueItem_Item `protobuf_oneof:"item"`
}

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

var xxx_messageInfo_QueueItem proto.InternalMessageInfo

type isQueueItem_Item interface {
	isQueueItem_Item()
	MarshalTo([]byte) (int, error)
	Size() int
}

type QueueItem_HandleToDecref struct {
	HandleToDecref *RemoteTensorHandle `protobuf:"bytes,1,opt,name=handle_to_decref,json=handleToDecref,proto3,oneof"`
}
type QueueItem_Operation struct {
	Operation *Operation `protobuf:"bytes,2,opt,name=operation,proto3,oneof"`
}

func (*QueueItem_HandleToDecref) isQueueItem_Item() {}
func (*QueueItem_Operation) isQueueItem_Item()      {}

func (m *QueueItem) GetItem() isQueueItem_Item {
	if m != nil {
		return m.Item
	}
	return nil
}

func (m *QueueItem) GetHandleToDecref() *RemoteTensorHandle {
	if x, ok := m.GetItem().(*QueueItem_HandleToDecref); ok {
		return x.HandleToDecref
	}
	return nil
}

func (m *QueueItem) GetOperation() *Operation {
	if x, ok := m.GetItem().(*QueueItem_Operation); ok {
		return x.Operation
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*QueueItem) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _QueueItem_OneofMarshaler, _QueueItem_OneofUnmarshaler, _QueueItem_OneofSizer, []interface{}{
		(*QueueItem_HandleToDecref)(nil),
		(*QueueItem_Operation)(nil),
	}
}

func _QueueItem_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*QueueItem)
	// item
	switch x := m.Item.(type) {
	case *QueueItem_HandleToDecref:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.HandleToDecref); err != nil {
			return err
		}
	case *QueueItem_Operation:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Operation); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("QueueItem.Item has unexpected type %T", x)
	}
	return nil
}

func _QueueItem_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*QueueItem)
	switch tag {
	case 1: // item.handle_to_decref
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RemoteTensorHandle)
		err := b.DecodeMessage(msg)
		m.Item = &QueueItem_HandleToDecref{msg}
		return true, err
	case 2: // item.operation
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Operation)
		err := b.DecodeMessage(msg)
		m.Item = &QueueItem_Operation{msg}
		return true, err
	default:
		return false, nil
	}
}

func _QueueItem_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*QueueItem)
	// item
	switch x := m.Item.(type) {
	case *QueueItem_HandleToDecref:
		s := proto.Size(x.HandleToDecref)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *QueueItem_Operation:
		s := proto.Size(x.Operation)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

type QueueResponse struct {
	Shape []*TensorShapeProto `protobuf:"bytes,1,rep,name=shape,proto3" json:"shape,omitempty"`
}

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

var xxx_messageInfo_QueueResponse proto.InternalMessageInfo

func (m *QueueResponse) GetShape() []*TensorShapeProto {
	if m != nil {
		return m.Shape
	}
	return nil
}

type CreateContextRequest struct {
	// Identifies the full cluster, and this particular worker's position within.
	ServerDef *ServerDef `protobuf:"bytes,1,opt,name=server_def,json=serverDef,proto3" json:"server_def,omitempty"`
	// Whether the ops on the worker should be executed synchronously or
	// asynchronously. By default, ops are executed synchronously.
	Async bool `protobuf:"varint,2,opt,name=async,proto3" json:"async,omitempty"`
	// Number of seconds to keep the context alive. If more than keep_alive_secs
	// has passed since a particular context has been communicated with, it will
	// be garbage collected.
	KeepAliveSecs int64 `protobuf:"varint,3,opt,name=keep_alive_secs,json=keepAliveSecs,proto3" json:"keep_alive_secs,omitempty"`
	// This is the version for all the ops that will be enqueued by the client.
	VersionDef *VersionDef `protobuf:"bytes,4,opt,name=version_def,json=versionDef,proto3" json:"version_def,omitempty"`
	// This ID will be used for all future communications. It is essential that
	// both ends use this ID for selecting a rendezvous to get everything to
	// match.
	RendezvousId int64 `protobuf:"varint,5,opt,name=rendezvous_id,json=rendezvousId,proto3" json:"rendezvous_id,omitempty"`
}

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

var xxx_messageInfo_CreateContextRequest proto.InternalMessageInfo

func (m *CreateContextRequest) GetServerDef() *ServerDef {
	if m != nil {
		return m.ServerDef
	}
	return nil
}

func (m *CreateContextRequest) GetAsync() bool {
	if m != nil {
		return m.Async
	}
	return false
}

func (m *CreateContextRequest) GetKeepAliveSecs() int64 {
	if m != nil {
		return m.KeepAliveSecs
	}
	return 0
}

func (m *CreateContextRequest) GetVersionDef() *VersionDef {
	if m != nil {
		return m.VersionDef
	}
	return nil
}

func (m *CreateContextRequest) GetRendezvousId() int64 {
	if m != nil {
		return m.RendezvousId
	}
	return 0
}

type CreateContextResponse struct {
	// The ID of the created context. This is usually a randomly generated number,
	// that will be used to identify the context in future requests to the
	// service. Contexts are not persisted through server restarts.
	ContextId uint64 `protobuf:"fixed64,1,opt,name=context_id,json=contextId,proto3" json:"context_id,omitempty"`
	// List of devices that are locally accessible to the worker.
	DeviceAttributes []*DeviceAttributes `protobuf:"bytes,2,rep,name=device_attributes,json=deviceAttributes,proto3" json:"device_attributes,omitempty"`
}

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

var xxx_messageInfo_CreateContextResponse proto.InternalMessageInfo

func (m *CreateContextResponse) GetContextId() uint64 {
	if m != nil {
		return m.ContextId
	}
	return 0
}

func (m *CreateContextResponse) GetDeviceAttributes() []*DeviceAttributes {
	if m != nil {
		return m.DeviceAttributes
	}
	return nil
}

type EnqueueRequest struct {
	ContextId uint64       `protobuf:"fixed64,1,opt,name=context_id,json=contextId,proto3" json:"context_id,omitempty"`
	Queue     []*QueueItem `protobuf:"bytes,3,rep,name=queue,proto3" json:"queue,omitempty"`
}

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

var xxx_messageInfo_EnqueueRequest proto.InternalMessageInfo

func (m *EnqueueRequest) GetContextId() uint64 {
	if m != nil {
		return m.ContextId
	}
	return 0
}

func (m *EnqueueRequest) GetQueue() []*QueueItem {
	if m != nil {
		return m.Queue
	}
	return nil
}

type EnqueueResponse struct {
	// A single operation response for every item in the request.
	QueueResponse []*QueueResponse `protobuf:"bytes,1,rep,name=queue_response,json=queueResponse,proto3" json:"queue_response,omitempty"`
}

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

var xxx_messageInfo_EnqueueResponse proto.InternalMessageInfo

func (m *EnqueueResponse) GetQueueResponse() []*QueueResponse {
	if m != nil {
		return m.QueueResponse
	}
	return nil
}

type WaitQueueDoneRequest struct {
	ContextId uint64 `protobuf:"fixed64,1,opt,name=context_id,json=contextId,proto3" json:"context_id,omitempty"`
	// Ids to wait on. If empty, wait on everything currently pending.
	OpId []int64 `protobuf:"varint,2,rep,packed,name=op_id,json=opId,proto3" json:"op_id,omitempty"`
}

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

var xxx_messageInfo_WaitQueueDoneRequest proto.InternalMessageInfo

func (m *WaitQueueDoneRequest) GetContextId() uint64 {
	if m != nil {
		return m.ContextId
	}
	return 0
}

func (m *WaitQueueDoneRequest) GetOpId() []int64 {
	if m != nil {
		return m.OpId
	}
	return nil
}

type WaitQueueDoneResponse struct {
}

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

var xxx_messageInfo_WaitQueueDoneResponse proto.InternalMessageInfo

type KeepAliveRequest struct {
	ContextId uint64 `protobuf:"fixed64,1,opt,name=context_id,json=contextId,proto3" json:"context_id,omitempty"`
}

func (m *KeepAliveRequest) Reset()         { *m = KeepAliveRequest{} }
func (m *KeepAliveRequest) String() string { return proto.CompactTextString(m) }
func (*KeepAliveRequest) ProtoMessage()    {}
func (*KeepAliveRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_057710a5cefb6c51, []int{10}
}
func (m *KeepAliveRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeepAliveRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeepAliveRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KeepAliveRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeepAliveRequest.Merge(m, src)
}
func (m *KeepAliveRequest) XXX_Size() int {
	return m.Size()
}
func (m *KeepAliveRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_KeepAliveRequest.DiscardUnknown(m)
}

var xxx_messageInfo_KeepAliveRequest proto.InternalMessageInfo

func (m *KeepAliveRequest) GetContextId() uint64 {
	if m != nil {
		return m.ContextId
	}
	return 0
}

type KeepAliveResponse struct {
}

func (m *KeepAliveResponse) Reset()         { *m = KeepAliveResponse{} }
func (m *KeepAliveResponse) String() string { return proto.CompactTextString(m) }
func (*KeepAliveResponse) ProtoMessage()    {}
func (*KeepAliveResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_057710a5cefb6c51, []int{11}
}
func (m *KeepAliveResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *KeepAliveResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_KeepAliveResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *KeepAliveResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KeepAliveResponse.Merge(m, src)
}
func (m *KeepAliveResponse) XXX_Size() int {
	return m.Size()
}
func (m *KeepAliveResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_KeepAliveResponse.DiscardUnknown(m)
}

var xxx_messageInfo_KeepAliveResponse proto.InternalMessageInfo

type CloseContextRequest struct {
	ContextId uint64 `protobuf:"fixed64,1,opt,name=context_id,json=contextId,proto3" json:"context_id,omitempty"`
}

func (m *CloseContextRequest) Reset()         { *m = CloseContextRequest{} }
func (m *CloseContextRequest) String() string { return proto.CompactTextString(m) }
func (*CloseContextRequest) ProtoMessage()    {}
func (*CloseContextRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_057710a5cefb6c51, []int{12}
}
func (m *CloseContextRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloseContextRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseContextRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CloseContextRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseContextRequest.Merge(m, src)
}
func (m *CloseContextRequest) XXX_Size() int {
	return m.Size()
}
func (m *CloseContextRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseContextRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CloseContextRequest proto.InternalMessageInfo

func (m *CloseContextRequest) GetContextId() uint64 {
	if m != nil {
		return m.ContextId
	}
	return 0
}

type CloseContextResponse struct {
}

func (m *CloseContextResponse) Reset()         { *m = CloseContextResponse{} }
func (m *CloseContextResponse) String() string { return proto.CompactTextString(m) }
func (*CloseContextResponse) ProtoMessage()    {}
func (*CloseContextResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_057710a5cefb6c51, []int{13}
}
func (m *CloseContextResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CloseContextResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CloseContextResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CloseContextResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CloseContextResponse.Merge(m, src)
}
func (m *CloseContextResponse) XXX_Size() int {
	return m.Size()
}
func (m *CloseContextResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CloseContextResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CloseContextResponse proto.InternalMessageInfo

type RegisterFunctionRequest struct {
	ContextId   uint64       `protobuf:"fixed64,1,opt,name=context_id,json=contextId,proto3" json:"context_id,omitempty"`
	FunctionDef *FunctionDef `protobuf:"bytes,2,opt,name=function_def,json=functionDef,proto3" json:"function_def,omitempty"`
}

func (m *RegisterFunctionRequest) Reset()         { *m = RegisterFunctionRequest{} }
func (m *RegisterFunctionRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterFunctionRequest) ProtoMessage()    {}
func (*RegisterFunctionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_057710a5cefb6c51, []int{14}
}
func (m *RegisterFunctionRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterFunctionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterFunctionRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterFunctionRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterFunctionRequest.Merge(m, src)
}
func (m *RegisterFunctionRequest) XXX_Size() int {
	return m.Size()
}
func (m *RegisterFunctionRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterFunctionRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterFunctionRequest proto.InternalMessageInfo

func (m *RegisterFunctionRequest) GetContextId() uint64 {
	if m != nil {
		return m.ContextId
	}
	return 0
}

func (m *RegisterFunctionRequest) GetFunctionDef() *FunctionDef {
	if m != nil {
		return m.FunctionDef
	}
	return nil
}

type RegisterFunctionResponse struct {
}

func (m *RegisterFunctionResponse) Reset()         { *m = RegisterFunctionResponse{} }
func (m *RegisterFunctionResponse) String() string { return proto.CompactTextString(m) }
func (*RegisterFunctionResponse) ProtoMessage()    {}
func (*RegisterFunctionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_057710a5cefb6c51, []int{15}
}
func (m *RegisterFunctionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterFunctionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterFunctionResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RegisterFunctionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterFunctionResponse.Merge(m, src)
}
func (m *RegisterFunctionResponse) XXX_Size() int {
	return m.Size()
}
func (m *RegisterFunctionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterFunctionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterFunctionResponse proto.InternalMessageInfo

type SendTensorRequest struct {
	ContextId uint64 `protobuf:"fixed64,1,opt,name=context_id,json=contextId,proto3" json:"context_id,omitempty"`
	// All remote tensors are identified by <Op ID, Output num>. To mimic this
	// situation when directly sending tensors, we include an "artificial" op ID
	// (which would have corresponded to the _Recv op when not using SendTensor).
	OpId int64 `protobuf:"varint,2,opt,name=op_id,json=opId,proto3" json:"op_id,omitempty"`
	// The index within the repeated field is the output number that will help
	// uniquely identify (along with the above op_id) the particular tensor.
	Tensors []*TensorProto `protobuf:"bytes,3,rep,name=tensors,proto3" json:"tensors,omitempty"`
	// The device on which the tensors should be resident.
	DeviceName string `protobuf:"bytes,4,opt,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
}

func (m *SendTensorRequest) Reset()         { *m = SendTensorRequest{} }
func (m *SendTensorRequest) String() string { return proto.CompactTextString(m) }
func (*SendTensorRequest) ProtoMessage()    {}
func (*SendTensorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_057710a5cefb6c51, []int{16}
}
func (m *SendTensorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SendTensorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SendTensorRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SendTensorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendTensorRequest.Merge(m, src)
}
func (m *SendTensorRequest) XXX_Size() int {
	return m.Size()
}
func (m *SendTensorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SendTensorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SendTensorRequest proto.InternalMessageInfo

func (m *SendTensorRequest) GetContextId() uint64 {
	if m != nil {
		return m.ContextId
	}
	return 0
}

func (m *SendTensorRequest) GetOpId() int64 {
	if m != nil {
		return m.OpId
	}
	return 0
}

func (m *SendTensorRequest) GetTensors() []*TensorProto {
	if m != nil {
		return m.Tensors
	}
	return nil
}

func (m *SendTensorRequest) GetDeviceName() string {
	if m != nil {
		return m.DeviceName
	}
	return ""
}

type SendTensorResponse struct {
}

func (m *SendTensorResponse) Reset()         { *m = SendTensorResponse{} }
func (m *SendTensorResponse) String() string { return proto.CompactTextString(m) }
func (*SendTensorResponse) ProtoMessage()    {}
func (*SendTensorResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_057710a5cefb6c51, []int{17}
}
func (m *SendTensorResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SendTensorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SendTensorResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SendTensorResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SendTensorResponse.Merge(m, src)
}
func (m *SendTensorResponse) XXX_Size() int {
	return m.Size()
}
func (m *SendTensorResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SendTensorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SendTensorResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*RemoteTensorHandle)(nil), "tensorflow.eager.RemoteTensorHandle")
	proto.RegisterType((*Operation)(nil), "tensorflow.eager.Operation")
	proto.RegisterMapType((map[string]*AttrValue)(nil), "tensorflow.eager.Operation.AttrsEntry")
	proto.RegisterType((*QueueItem)(nil), "tensorflow.eager.QueueItem")
	proto.RegisterType((*QueueResponse)(nil), "tensorflow.eager.QueueResponse")
	proto.RegisterType((*CreateContextRequest)(nil), "tensorflow.eager.CreateContextRequest")
	proto.RegisterType((*CreateContextResponse)(nil), "tensorflow.eager.CreateContextResponse")
	proto.RegisterType((*EnqueueRequest)(nil), "tensorflow.eager.EnqueueRequest")
	proto.RegisterType((*EnqueueResponse)(nil), "tensorflow.eager.EnqueueResponse")
	proto.RegisterType((*WaitQueueDoneRequest)(nil), "tensorflow.eager.WaitQueueDoneRequest")
	proto.RegisterType((*WaitQueueDoneResponse)(nil), "tensorflow.eager.WaitQueueDoneResponse")
	proto.RegisterType((*KeepAliveRequest)(nil), "tensorflow.eager.KeepAliveRequest")
	proto.RegisterType((*KeepAliveResponse)(nil), "tensorflow.eager.KeepAliveResponse")
	proto.RegisterType((*CloseContextRequest)(nil), "tensorflow.eager.CloseContextRequest")
	proto.RegisterType((*CloseContextResponse)(nil), "tensorflow.eager.CloseContextResponse")
	proto.RegisterType((*RegisterFunctionRequest)(nil), "tensorflow.eager.RegisterFunctionRequest")
	proto.RegisterType((*RegisterFunctionResponse)(nil), "tensorflow.eager.RegisterFunctionResponse")
	proto.RegisterType((*SendTensorRequest)(nil), "tensorflow.eager.SendTensorRequest")
	proto.RegisterType((*SendTensorResponse)(nil), "tensorflow.eager.SendTensorResponse")
}

func init() { proto.RegisterFile("eager_service.proto", fileDescriptor_057710a5cefb6c51) }

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

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

// EagerServiceClient is the client API for EagerService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type EagerServiceClient interface {
	// This initializes the worker, informing it about the other workers in the
	// cluster and exchanging authentication tokens which will be used in all
	// other RPCs to detect whether the worker has restarted.
	CreateContext(ctx context.Context, in *CreateContextRequest, opts ...grpc.CallOption) (*CreateContextResponse, error)
	// This takes a list of Execute and DeleteTensorHandle operations and enqueues
	// (in async mode) or executes (in sync mode) them on the remote server.
	// All outputs of ops which were not explicitly deleted with
	// DeleteTensorHandle entries will be assumed to be alive and are usable by
	// future calls to Enqueue.
	Enqueue(ctx context.Context, in *EnqueueRequest, opts ...grpc.CallOption) (*EnqueueResponse, error)
	// Takes a set of op IDs and waits until those ops are done. Returns any error
	// in the stream so far.
	WaitQueueDone(ctx context.Context, in *WaitQueueDoneRequest, opts ...grpc.CallOption) (*WaitQueueDoneResponse, error)
	// Contexts are always created with a deadline and no RPCs within a deadline
	// will trigger a context garbage collection. KeepAlive calls can be used to
	// delay this.
	KeepAlive(ctx context.Context, in *KeepAliveRequest, opts ...grpc.CallOption) (*KeepAliveResponse, error)
	// Closes the context. No calls to other methods using the existing context ID
	// are valid after this.
	CloseContext(ctx context.Context, in *CloseContextRequest, opts ...grpc.CallOption) (*CloseContextResponse, error)
	// Takes a FunctionDef and makes it enqueable on the remote worker.
	RegisterFunction(ctx context.Context, in *RegisterFunctionRequest, opts ...grpc.CallOption) (*RegisterFunctionResponse, error)
	// An RPC to push tensors to the server. At times, certain environments don't
	// allow the server to connect back to the client.
	SendTensor(ctx context.Context, in *SendTensorRequest, opts ...grpc.CallOption) (*SendTensorResponse, error)
}

type eagerServiceClient struct {
	cc *grpc.ClientConn
}

func NewEagerServiceClient(cc *grpc.ClientConn) EagerServiceClient {
	return &eagerServiceClient{cc}
}

func (c *eagerServiceClient) CreateContext(ctx context.Context, in *CreateContextRequest, opts ...grpc.CallOption) (*CreateContextResponse, error) {
	out := new(CreateContextResponse)
	err := c.cc.Invoke(ctx, "/tensorflow.eager.EagerService/CreateContext", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *eagerServiceClient) Enqueue(ctx context.Context, in *EnqueueRequest, opts ...grpc.CallOption) (*EnqueueResponse, error) {
	out := new(EnqueueResponse)
	err := c.cc.Invoke(ctx, "/tensorflow.eager.EagerService/Enqueue", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *eagerServiceClient) WaitQueueDone(ctx context.Context, in *WaitQueueDoneRequest, opts ...grpc.CallOption) (*WaitQueueDoneResponse, error) {
	out := new(WaitQueueDoneResponse)
	err := c.cc.Invoke(ctx, "/tensorflow.eager.EagerService/WaitQueueDone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *eagerServiceClient) KeepAlive(ctx context.Context, in *KeepAliveRequest, opts ...grpc.CallOption) (*KeepAliveResponse, error) {
	out := new(KeepAliveResponse)
	err := c.cc.Invoke(ctx, "/tensorflow.eager.EagerService/KeepAlive", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *eagerServiceClient) CloseContext(ctx context.Context, in *CloseContextRequest, opts ...grpc.CallOption) (*CloseContextResponse, error) {
	out := new(CloseContextResponse)
	err := c.cc.Invoke(ctx, "/tensorflow.eager.EagerService/CloseContext", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *eagerServiceClient) RegisterFunction(ctx context.Context, in *RegisterFunctionRequest, opts ...grpc.CallOption) (*RegisterFunctionResponse, error) {
	out := new(RegisterFunctionResponse)
	err := c.cc.Invoke(ctx, "/tensorflow.eager.EagerService/RegisterFunction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *eagerServiceClient) SendTensor(ctx context.Context, in *SendTensorRequest, opts ...grpc.CallOption) (*SendTensorResponse, error) {
	out := new(SendTensorResponse)
	err := c.cc.Invoke(ctx, "/tensorflow.eager.EagerService/SendTensor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// EagerServiceServer is the server API for EagerService service.
type EagerServiceServer interface {
	// This initializes the worker, informing it about the other workers in the
	// cluster and exchanging authentication tokens which will be used in all
	// other RPCs to detect whether the worker has restarted.
	CreateContext(context.Context, *CreateContextRequest) (*CreateContextResponse, error)
	// This takes a list of Execute and DeleteTensorHandle operations and enqueues
	// (in async mode) or executes (in sync mode) them on the remote server.
	// All outputs of ops which were not explicitly deleted with
	// DeleteTensorHandle entries will be assumed to be alive and are usable by
	// future calls to Enqueue.
	Enqueue(context.Context, *EnqueueRequest) (*EnqueueResponse, error)
	// Takes a set of op IDs and waits until those ops are done. Returns any error
	// in the stream so far.
	WaitQueueDone(context.Context, *WaitQueueDoneRequest) (*WaitQueueDoneResponse, error)
	// Contexts are always created with a deadline and no RPCs within a deadline
	// will trigger a context garbage collection. KeepAlive calls can be used to
	// delay this.
	KeepAlive(context.Context, *KeepAliveRequest) (*KeepAliveResponse, error)
	// Closes the context. No calls to other methods using the existing context ID
	// are valid after this.
	CloseContext(context.Context, *CloseContextRequest) (*CloseContextResponse, error)
	// Takes a FunctionDef and makes it enqueable on the remote worker.
	RegisterFunction(context.Context, *RegisterFunctionRequest) (*RegisterFunctionResponse, error)
	// An RPC to push tensors to the server. At times, certain environments don't
	// allow the server to connect back to the client.
	SendTensor(context.Context, *SendTensorRequest) (*SendTensorResponse, error)
}

func RegisterEagerServiceServer(s *grpc.Server, srv EagerServiceServer) {
	s.RegisterService(&_EagerService_serviceDesc, srv)
}

func _EagerService_CreateContext_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateContextRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EagerServiceServer).CreateContext(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tensorflow.eager.EagerService/CreateContext",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EagerServiceServer).CreateContext(ctx, req.(*CreateContextRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EagerService_Enqueue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnqueueRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EagerServiceServer).Enqueue(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tensorflow.eager.EagerService/Enqueue",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EagerServiceServer).Enqueue(ctx, req.(*EnqueueRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EagerService_WaitQueueDone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(WaitQueueDoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EagerServiceServer).WaitQueueDone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tensorflow.eager.EagerService/WaitQueueDone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EagerServiceServer).WaitQueueDone(ctx, req.(*WaitQueueDoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EagerService_KeepAlive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(KeepAliveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EagerServiceServer).KeepAlive(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tensorflow.eager.EagerService/KeepAlive",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EagerServiceServer).KeepAlive(ctx, req.(*KeepAliveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EagerService_CloseContext_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CloseContextRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EagerServiceServer).CloseContext(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tensorflow.eager.EagerService/CloseContext",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EagerServiceServer).CloseContext(ctx, req.(*CloseContextRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EagerService_RegisterFunction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterFunctionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EagerServiceServer).RegisterFunction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tensorflow.eager.EagerService/RegisterFunction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EagerServiceServer).RegisterFunction(ctx, req.(*RegisterFunctionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EagerService_SendTensor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SendTensorRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EagerServiceServer).SendTensor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tensorflow.eager.EagerService/SendTensor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EagerServiceServer).SendTensor(ctx, req.(*SendTensorRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _EagerService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "tensorflow.eager.EagerService",
	HandlerType: (*EagerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateContext",
			Handler:    _EagerService_CreateContext_Handler,
		},
		{
			MethodName: "Enqueue",
			Handler:    _EagerService_Enqueue_Handler,
		},
		{
			MethodName: "WaitQueueDone",
			Handler:    _EagerService_WaitQueueDone_Handler,
		},
		{
			MethodName: "KeepAlive",
			Handler:    _EagerService_KeepAlive_Handler,
		},
		{
			MethodName: "CloseContext",
			Handler:    _EagerService_CloseContext_Handler,
		},
		{
			MethodName: "RegisterFunction",
			Handler:    _EagerService_RegisterFunction_Handler,
		},
		{
			MethodName: "SendTensor",
			Handler:    _EagerService_SendTensor_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "eager_service.proto",
}

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

func (m *RemoteTensorHandle) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.OpId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.OpId))
	}
	if m.OutputNum != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.OutputNum))
	}
	return i, nil
}

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

func (m *Operation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.Id))
	}
	if len(m.Name) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Inputs) > 0 {
		for _, msg := range m.Inputs {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintEagerService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.ControlOpIds) > 0 {
		dAtA2 := make([]byte, len(m.ControlOpIds)*10)
		var j1 int
		for _, num1 := range m.ControlOpIds {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		dAtA[i] = 0x22
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(j1))
		i += copy(dAtA[i:], dAtA2[:j1])
	}
	if len(m.Attrs) > 0 {
		for k := range m.Attrs {
			dAtA[i] = 0x2a
			i++
			v := m.Attrs[k]
			msgSize := 0
			if v != nil {
				msgSize = v.Size()
				msgSize += 1 + sovEagerService(uint64(msgSize))
			}
			mapSize := 1 + len(k) + sovEagerService(uint64(len(k))) + msgSize
			i = encodeVarintEagerService(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintEagerService(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			if v != nil {
				dAtA[i] = 0x12
				i++
				i = encodeVarintEagerService(dAtA, i, uint64(v.Size()))
				n3, err3 := v.MarshalTo(dAtA[i:])
				if err3 != nil {
					return 0, err3
				}
				i += n3
			}
		}
	}
	if len(m.Device) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(len(m.Device)))
		i += copy(dAtA[i:], m.Device)
	}
	return i, nil
}

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

func (m *QueueItem) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Item != nil {
		nn4, err4 := m.Item.MarshalTo(dAtA[i:])
		if err4 != nil {
			return 0, err4
		}
		i += nn4
	}
	return i, nil
}

func (m *QueueItem_HandleToDecref) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.HandleToDecref != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.HandleToDecref.Size()))
		n5, err5 := m.HandleToDecref.MarshalTo(dAtA[i:])
		if err5 != nil {
			return 0, err5
		}
		i += n5
	}
	return i, nil
}
func (m *QueueItem_Operation) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Operation != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.Operation.Size()))
		n6, err6 := m.Operation.MarshalTo(dAtA[i:])
		if err6 != nil {
			return 0, err6
		}
		i += n6
	}
	return i, nil
}
func (m *QueueResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *QueueResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Shape) > 0 {
		for _, msg := range m.Shape {
			dAtA[i] = 0xa
			i++
			i = encodeVarintEagerService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *CreateContextRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ServerDef != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.ServerDef.Size()))
		n7, err7 := m.ServerDef.MarshalTo(dAtA[i:])
		if err7 != nil {
			return 0, err7
		}
		i += n7
	}
	if m.Async {
		dAtA[i] = 0x10
		i++
		if m.Async {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.KeepAliveSecs != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.KeepAliveSecs))
	}
	if m.VersionDef != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.VersionDef.Size()))
		n8, err8 := m.VersionDef.MarshalTo(dAtA[i:])
		if err8 != nil {
			return 0, err8
		}
		i += n8
	}
	if m.RendezvousId != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.RendezvousId))
	}
	return i, nil
}

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

func (m *CreateContextResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContextId != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.ContextId))
		i += 8
	}
	if len(m.DeviceAttributes) > 0 {
		for _, msg := range m.DeviceAttributes {
			dAtA[i] = 0x12
			i++
			i = encodeVarintEagerService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *EnqueueRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContextId != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.ContextId))
		i += 8
	}
	if len(m.Queue) > 0 {
		for _, msg := range m.Queue {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintEagerService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *EnqueueResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.QueueResponse) > 0 {
		for _, msg := range m.QueueResponse {
			dAtA[i] = 0xa
			i++
			i = encodeVarintEagerService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *WaitQueueDoneRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContextId != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.ContextId))
		i += 8
	}
	if len(m.OpId) > 0 {
		dAtA10 := make([]byte, len(m.OpId)*10)
		var j9 int
		for _, num1 := range m.OpId {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA10[j9] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j9++
			}
			dAtA10[j9] = uint8(num)
			j9++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(j9))
		i += copy(dAtA[i:], dAtA10[:j9])
	}
	return i, nil
}

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

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

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

func (m *KeepAliveRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContextId != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.ContextId))
		i += 8
	}
	return i, nil
}

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

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

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

func (m *CloseContextRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContextId != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.ContextId))
		i += 8
	}
	return i, nil
}

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

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

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

func (m *RegisterFunctionRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContextId != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.ContextId))
		i += 8
	}
	if m.FunctionDef != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.FunctionDef.Size()))
		n11, err11 := m.FunctionDef.MarshalTo(dAtA[i:])
		if err11 != nil {
			return 0, err11
		}
		i += n11
	}
	return i, nil
}

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

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

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

func (m *SendTensorRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContextId != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.ContextId))
		i += 8
	}
	if m.OpId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(m.OpId))
	}
	if len(m.Tensors) > 0 {
		for _, msg := range m.Tensors {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintEagerService(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.DeviceName) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintEagerService(dAtA, i, uint64(len(m.DeviceName)))
		i += copy(dAtA[i:], m.DeviceName)
	}
	return i, nil
}

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

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

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

func (m *Operation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovEagerService(uint64(m.Id))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovEagerService(uint64(l))
	}
	if len(m.Inputs) > 0 {
		for _, e := range m.Inputs {
			l = e.Size()
			n += 1 + l + sovEagerService(uint64(l))
		}
	}
	if len(m.ControlOpIds) > 0 {
		l = 0
		for _, e := range m.ControlOpIds {
			l += sovEagerService(uint64(e))
		}
		n += 1 + sovEagerService(uint64(l)) + l
	}
	if len(m.Attrs) > 0 {
		for k, v := range m.Attrs {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovEagerService(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovEagerService(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovEagerService(uint64(mapEntrySize))
		}
	}
	l = len(m.Device)
	if l > 0 {
		n += 1 + l + sovEagerService(uint64(l))
	}
	return n
}

func (m *QueueItem) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Item != nil {
		n += m.Item.Size()
	}
	return n
}

func (m *QueueItem_HandleToDecref) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.HandleToDecref != nil {
		l = m.HandleToDecref.Size()
		n += 1 + l + sovEagerService(uint64(l))
	}
	return n
}
func (m *QueueItem_Operation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Operation != nil {
		l = m.Operation.Size()
		n += 1 + l + sovEagerService(uint64(l))
	}
	return n
}
func (m *QueueResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Shape) > 0 {
		for _, e := range m.Shape {
			l = e.Size()
			n += 1 + l + sovEagerService(uint64(l))
		}
	}
	return n
}

func (m *CreateContextRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ServerDef != nil {
		l = m.ServerDef.Size()
		n += 1 + l + sovEagerService(uint64(l))
	}
	if m.Async {
		n += 2
	}
	if m.KeepAliveSecs != 0 {
		n += 1 + sovEagerService(uint64(m.KeepAliveSecs))
	}
	if m.VersionDef != nil {
		l = m.VersionDef.Size()
		n += 1 + l + sovEagerService(uint64(l))
	}
	if m.RendezvousId != 0 {
		n += 1 + sovEagerService(uint64(m.RendezvousId))
	}
	return n
}

func (m *CreateContextResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContextId != 0 {
		n += 9
	}
	if len(m.DeviceAttributes) > 0 {
		for _, e := range m.DeviceAttributes {
			l = e.Size()
			n += 1 + l + sovEagerService(uint64(l))
		}
	}
	return n
}

func (m *EnqueueRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContextId != 0 {
		n += 9
	}
	if len(m.Queue) > 0 {
		for _, e := range m.Queue {
			l = e.Size()
			n += 1 + l + sovEagerService(uint64(l))
		}
	}
	return n
}

func (m *EnqueueResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.QueueResponse) > 0 {
		for _, e := range m.QueueResponse {
			l = e.Size()
			n += 1 + l + sovEagerService(uint64(l))
		}
	}
	return n
}

func (m *WaitQueueDoneRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContextId != 0 {
		n += 9
	}
	if len(m.OpId) > 0 {
		l = 0
		for _, e := range m.OpId {
			l += sovEagerService(uint64(e))
		}
		n += 1 + sovEagerService(uint64(l)) + l
	}
	return n
}

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

func (m *KeepAliveRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContextId != 0 {
		n += 9
	}
	return n
}

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

func (m *CloseContextRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContextId != 0 {
		n += 9
	}
	return n
}

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

func (m *RegisterFunctionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContextId != 0 {
		n += 9
	}
	if m.FunctionDef != nil {
		l = m.FunctionDef.Size()
		n += 1 + l + sovEagerService(uint64(l))
	}
	return n
}

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

func (m *SendTensorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContextId != 0 {
		n += 9
	}
	if m.OpId != 0 {
		n += 1 + sovEagerService(uint64(m.OpId))
	}
	if len(m.Tensors) > 0 {
		for _, e := range m.Tensors {
			l = e.Size()
			n += 1 + l + sovEagerService(uint64(l))
		}
	}
	l = len(m.DeviceName)
	if l > 0 {
		n += 1 + l + sovEagerService(uint64(l))
	}
	return n
}

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

func sovEagerService(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozEagerService(x uint64) (n int) {
	return sovEagerService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RemoteTensorHandle) 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 ErrIntOverflowEagerService
			}
			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: RemoteTensorHandle: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RemoteTensorHandle: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpId", wireType)
			}
			m.OpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OpId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputNum", wireType)
			}
			m.OutputNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OutputNum |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Operation) 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 ErrIntOverflowEagerService
			}
			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: Operation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Operation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				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 ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inputs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Inputs = append(m.Inputs, &RemoteTensorHandle{})
			if err := m.Inputs[len(m.Inputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEagerService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.ControlOpIds = append(m.ControlOpIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEagerService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEagerService
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthEagerService
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.ControlOpIds) == 0 {
					m.ControlOpIds = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEagerService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.ControlOpIds = append(m.ControlOpIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlOpIds", wireType)
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Attrs == nil {
				m.Attrs = make(map[string]*AttrValue)
			}
			var mapkey string
			var mapvalue *AttrValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEagerService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEagerService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthEagerService
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthEagerService
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEagerService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthEagerService
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthEagerService
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &AttrValue{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipEagerService(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthEagerService
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Attrs[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Device", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				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 ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Device = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueueItem) 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 ErrIntOverflowEagerService
			}
			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: QueueItem: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueueItem: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HandleToDecref", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RemoteTensorHandle{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Item = &QueueItem_HandleToDecref{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Operation{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Item = &QueueItem_Operation{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueueResponse) 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 ErrIntOverflowEagerService
			}
			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: QueueResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueueResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shape", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Shape = append(m.Shape, &TensorShapeProto{})
			if err := m.Shape[len(m.Shape)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateContextRequest) 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 ErrIntOverflowEagerService
			}
			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: CreateContextRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateContextRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerDef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ServerDef == nil {
				m.ServerDef = &ServerDef{}
			}
			if err := m.ServerDef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Async", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Async = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeepAliveSecs", wireType)
			}
			m.KeepAliveSecs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KeepAliveSecs |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionDef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VersionDef == nil {
				m.VersionDef = &VersionDef{}
			}
			if err := m.VersionDef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RendezvousId", wireType)
			}
			m.RendezvousId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RendezvousId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateContextResponse) 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 ErrIntOverflowEagerService
			}
			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: CreateContextResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateContextResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			m.ContextId = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceAttributes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceAttributes = append(m.DeviceAttributes, &DeviceAttributes{})
			if err := m.DeviceAttributes[len(m.DeviceAttributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnqueueRequest) 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 ErrIntOverflowEagerService
			}
			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: EnqueueRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnqueueRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			m.ContextId = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Queue", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Queue = append(m.Queue, &QueueItem{})
			if err := m.Queue[len(m.Queue)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EnqueueResponse) 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 ErrIntOverflowEagerService
			}
			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: EnqueueResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EnqueueResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueueResponse = append(m.QueueResponse, &QueueResponse{})
			if err := m.QueueResponse[len(m.QueueResponse)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WaitQueueDoneRequest) 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 ErrIntOverflowEagerService
			}
			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: WaitQueueDoneRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WaitQueueDoneRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			m.ContextId = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 2:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEagerService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.OpId = append(m.OpId, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEagerService
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEagerService
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthEagerService
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.OpId) == 0 {
					m.OpId = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowEagerService
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.OpId = append(m.OpId, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field OpId", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *WaitQueueDoneResponse) 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 ErrIntOverflowEagerService
			}
			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: WaitQueueDoneResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WaitQueueDoneResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeepAliveRequest) 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 ErrIntOverflowEagerService
			}
			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: KeepAliveRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeepAliveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			m.ContextId = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *KeepAliveResponse) 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 ErrIntOverflowEagerService
			}
			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: KeepAliveResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KeepAliveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloseContextRequest) 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 ErrIntOverflowEagerService
			}
			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: CloseContextRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseContextRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			m.ContextId = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CloseContextResponse) 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 ErrIntOverflowEagerService
			}
			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: CloseContextResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CloseContextResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterFunctionRequest) 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 ErrIntOverflowEagerService
			}
			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: RegisterFunctionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterFunctionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			m.ContextId = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FunctionDef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FunctionDef == nil {
				m.FunctionDef = &FunctionDef{}
			}
			if err := m.FunctionDef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterFunctionResponse) 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 ErrIntOverflowEagerService
			}
			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: RegisterFunctionResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterFunctionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SendTensorRequest) 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 ErrIntOverflowEagerService
			}
			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: SendTensorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SendTensorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
			}
			m.ContextId = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.ContextId = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpId", wireType)
			}
			m.OpId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OpId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tensors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tensors = append(m.Tensors, &TensorProto{})
			if err := m.Tensors[len(m.Tensors)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEagerService
				}
				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 ErrInvalidLengthEagerService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEagerService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SendTensorResponse) 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 ErrIntOverflowEagerService
			}
			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: SendTensorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SendTensorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipEagerService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEagerService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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