worker.pb.go

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

package tensorflow

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	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 GetStatusRequest struct {
}

func (m *GetStatusRequest) Reset()         { *m = GetStatusRequest{} }
func (m *GetStatusRequest) String() string { return proto.CompactTextString(m) }
func (*GetStatusRequest) ProtoMessage()    {}
func (*GetStatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{0}
}
func (m *GetStatusRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetStatusRequest.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 *GetStatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetStatusRequest.Merge(m, src)
}
func (m *GetStatusRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetStatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetStatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetStatusRequest proto.InternalMessageInfo

type GetStatusResponse struct {
	DeviceAttributes []*DeviceAttributes `protobuf:"bytes,1,rep,name=device_attributes,json=deviceAttributes,proto3" json:"device_attributes,omitempty"`
}

func (m *GetStatusResponse) Reset()         { *m = GetStatusResponse{} }
func (m *GetStatusResponse) String() string { return proto.CompactTextString(m) }
func (*GetStatusResponse) ProtoMessage()    {}
func (*GetStatusResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{1}
}
func (m *GetStatusResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetStatusResponse.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 *GetStatusResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetStatusResponse.Merge(m, src)
}
func (m *GetStatusResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetStatusResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetStatusResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetStatusResponse proto.InternalMessageInfo

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

type CreateWorkerSessionRequest struct {
	// Sessions are identified by a given handle.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle,proto3" json:"session_handle,omitempty"`
	// Defines the configuration of a TensorFlow worker.
	ServerDef *ServerDef `protobuf:"bytes,2,opt,name=server_def,json=serverDef,proto3" json:"server_def,omitempty"`
	// If true, any resources such as Variables used in the session will not be
	// shared with other sessions.
	IsolateSessionState bool `protobuf:"varint,3,opt,name=isolate_session_state,json=isolateSessionState,proto3" json:"isolate_session_state,omitempty"`
}

func (m *CreateWorkerSessionRequest) Reset()         { *m = CreateWorkerSessionRequest{} }
func (m *CreateWorkerSessionRequest) String() string { return proto.CompactTextString(m) }
func (*CreateWorkerSessionRequest) ProtoMessage()    {}
func (*CreateWorkerSessionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{2}
}
func (m *CreateWorkerSessionRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateWorkerSessionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateWorkerSessionRequest.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 *CreateWorkerSessionRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateWorkerSessionRequest.Merge(m, src)
}
func (m *CreateWorkerSessionRequest) XXX_Size() int {
	return m.Size()
}
func (m *CreateWorkerSessionRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateWorkerSessionRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateWorkerSessionRequest proto.InternalMessageInfo

func (m *CreateWorkerSessionRequest) GetSessionHandle() string {
	if m != nil {
		return m.SessionHandle
	}
	return ""
}

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

func (m *CreateWorkerSessionRequest) GetIsolateSessionState() bool {
	if m != nil {
		return m.IsolateSessionState
	}
	return false
}

type CreateWorkerSessionResponse struct {
}

func (m *CreateWorkerSessionResponse) Reset()         { *m = CreateWorkerSessionResponse{} }
func (m *CreateWorkerSessionResponse) String() string { return proto.CompactTextString(m) }
func (*CreateWorkerSessionResponse) ProtoMessage()    {}
func (*CreateWorkerSessionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{3}
}
func (m *CreateWorkerSessionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CreateWorkerSessionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CreateWorkerSessionResponse.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 *CreateWorkerSessionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateWorkerSessionResponse.Merge(m, src)
}
func (m *CreateWorkerSessionResponse) XXX_Size() int {
	return m.Size()
}
func (m *CreateWorkerSessionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateWorkerSessionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateWorkerSessionResponse proto.InternalMessageInfo

type DeleteWorkerSessionRequest struct {
	// Sessions are identified by a given handle.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle,proto3" json:"session_handle,omitempty"`
}

func (m *DeleteWorkerSessionRequest) Reset()         { *m = DeleteWorkerSessionRequest{} }
func (m *DeleteWorkerSessionRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteWorkerSessionRequest) ProtoMessage()    {}
func (*DeleteWorkerSessionRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{4}
}
func (m *DeleteWorkerSessionRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteWorkerSessionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteWorkerSessionRequest.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 *DeleteWorkerSessionRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteWorkerSessionRequest.Merge(m, src)
}
func (m *DeleteWorkerSessionRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeleteWorkerSessionRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteWorkerSessionRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteWorkerSessionRequest proto.InternalMessageInfo

func (m *DeleteWorkerSessionRequest) GetSessionHandle() string {
	if m != nil {
		return m.SessionHandle
	}
	return ""
}

type DeleteWorkerSessionResponse struct {
}

func (m *DeleteWorkerSessionResponse) Reset()         { *m = DeleteWorkerSessionResponse{} }
func (m *DeleteWorkerSessionResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteWorkerSessionResponse) ProtoMessage()    {}
func (*DeleteWorkerSessionResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{5}
}
func (m *DeleteWorkerSessionResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeleteWorkerSessionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeleteWorkerSessionResponse.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 *DeleteWorkerSessionResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteWorkerSessionResponse.Merge(m, src)
}
func (m *DeleteWorkerSessionResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeleteWorkerSessionResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteWorkerSessionResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteWorkerSessionResponse proto.InternalMessageInfo

type RegisterGraphRequest struct {
	// Subgraphs are scoped within one session.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle,proto3" json:"session_handle,omitempty"`
	// Set to true if `CreateWorkerSession` was called for `session_handle`.
	CreateWorkerSessionCalled bool `protobuf:"varint,6,opt,name=create_worker_session_called,json=createWorkerSessionCalled,proto3" json:"create_worker_session_called,omitempty"`
	// "graph_def" has the subgraph of nodes for this worker, with each node
	// having its device_name filled in.
	GraphDef *GraphDef `protobuf:"bytes,2,opt,name=graph_def,json=graphDef,proto3" json:"graph_def,omitempty"`
	// True iff the graph (before partitioning) contains control flow nodes.
	//
	// As of 01/11/2015, this is no longer set by clients.
	HasControlFlow bool `protobuf:"varint,3,opt,name=has_control_flow,json=hasControlFlow,proto3" json:"has_control_flow,omitempty"` // Deprecated: Do not use.
	// Configuration options for the session in which this graph was created.
	GraphOptions *GraphOptions `protobuf:"bytes,4,opt,name=graph_options,json=graphOptions,proto3" json:"graph_options,omitempty"`
	// Field(s) used by TensorFlow Debugger (tfdbg).
	DebugOptions *DebugOptions `protobuf:"bytes,5,opt,name=debug_options,json=debugOptions,proto3" json:"debug_options,omitempty"`
	// If graph_def contains any collective ops this must be a positive
	// integer used to coordinate execution with other graphs.  All
	// graphs in a distributed execution with the same
	// collective_graph_key will coordinate to use the same step_id
	// concurrently so that BufRendezvous entries will make the correct
	// values accessible.
	CollectiveGraphKey int64 `protobuf:"varint,7,opt,name=collective_graph_key,json=collectiveGraphKey,proto3" json:"collective_graph_key,omitempty"`
}

func (m *RegisterGraphRequest) Reset()         { *m = RegisterGraphRequest{} }
func (m *RegisterGraphRequest) String() string { return proto.CompactTextString(m) }
func (*RegisterGraphRequest) ProtoMessage()    {}
func (*RegisterGraphRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{6}
}
func (m *RegisterGraphRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterGraphRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterGraphRequest.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 *RegisterGraphRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterGraphRequest.Merge(m, src)
}
func (m *RegisterGraphRequest) XXX_Size() int {
	return m.Size()
}
func (m *RegisterGraphRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterGraphRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterGraphRequest proto.InternalMessageInfo

func (m *RegisterGraphRequest) GetSessionHandle() string {
	if m != nil {
		return m.SessionHandle
	}
	return ""
}

func (m *RegisterGraphRequest) GetCreateWorkerSessionCalled() bool {
	if m != nil {
		return m.CreateWorkerSessionCalled
	}
	return false
}

func (m *RegisterGraphRequest) GetGraphDef() *GraphDef {
	if m != nil {
		return m.GraphDef
	}
	return nil
}

// Deprecated: Do not use.
func (m *RegisterGraphRequest) GetHasControlFlow() bool {
	if m != nil {
		return m.HasControlFlow
	}
	return false
}

func (m *RegisterGraphRequest) GetGraphOptions() *GraphOptions {
	if m != nil {
		return m.GraphOptions
	}
	return nil
}

func (m *RegisterGraphRequest) GetDebugOptions() *DebugOptions {
	if m != nil {
		return m.DebugOptions
	}
	return nil
}

func (m *RegisterGraphRequest) GetCollectiveGraphKey() int64 {
	if m != nil {
		return m.CollectiveGraphKey
	}
	return 0
}

type RegisterGraphResponse struct {
	// If the registration succeeds, returns an opaque graph_handle to
	// the master. The master calls RunGraph with graph_handle to
	// compute different steps.
	GraphHandle string `protobuf:"bytes,1,opt,name=graph_handle,json=graphHandle,proto3" json:"graph_handle,omitempty"`
}

func (m *RegisterGraphResponse) Reset()         { *m = RegisterGraphResponse{} }
func (m *RegisterGraphResponse) String() string { return proto.CompactTextString(m) }
func (*RegisterGraphResponse) ProtoMessage()    {}
func (*RegisterGraphResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{7}
}
func (m *RegisterGraphResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RegisterGraphResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RegisterGraphResponse.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 *RegisterGraphResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RegisterGraphResponse.Merge(m, src)
}
func (m *RegisterGraphResponse) XXX_Size() int {
	return m.Size()
}
func (m *RegisterGraphResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RegisterGraphResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RegisterGraphResponse proto.InternalMessageInfo

func (m *RegisterGraphResponse) GetGraphHandle() string {
	if m != nil {
		return m.GraphHandle
	}
	return ""
}

type DeregisterGraphRequest struct {
	// The session_handle used when registering the graph. If session_handle is
	// empty, a single global namespace is used.
	SessionHandle string `protobuf:"bytes,2,opt,name=session_handle,json=sessionHandle,proto3" json:"session_handle,omitempty"`
	// Set to true if `CreateWorkerSession` was called for `session_handle`.
	CreateWorkerSessionCalled bool `protobuf:"varint,3,opt,name=create_worker_session_called,json=createWorkerSessionCalled,proto3" json:"create_worker_session_called,omitempty"`
	// REQUIRED: graph_handle must be returned by a RegisterGraph call
	// to the same WorkerService.
	GraphHandle string `protobuf:"bytes,1,opt,name=graph_handle,json=graphHandle,proto3" json:"graph_handle,omitempty"`
}

func (m *DeregisterGraphRequest) Reset()         { *m = DeregisterGraphRequest{} }
func (m *DeregisterGraphRequest) String() string { return proto.CompactTextString(m) }
func (*DeregisterGraphRequest) ProtoMessage()    {}
func (*DeregisterGraphRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{8}
}
func (m *DeregisterGraphRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeregisterGraphRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeregisterGraphRequest.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 *DeregisterGraphRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeregisterGraphRequest.Merge(m, src)
}
func (m *DeregisterGraphRequest) XXX_Size() int {
	return m.Size()
}
func (m *DeregisterGraphRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeregisterGraphRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeregisterGraphRequest proto.InternalMessageInfo

func (m *DeregisterGraphRequest) GetSessionHandle() string {
	if m != nil {
		return m.SessionHandle
	}
	return ""
}

func (m *DeregisterGraphRequest) GetCreateWorkerSessionCalled() bool {
	if m != nil {
		return m.CreateWorkerSessionCalled
	}
	return false
}

func (m *DeregisterGraphRequest) GetGraphHandle() string {
	if m != nil {
		return m.GraphHandle
	}
	return ""
}

type DeregisterGraphResponse struct {
}

func (m *DeregisterGraphResponse) Reset()         { *m = DeregisterGraphResponse{} }
func (m *DeregisterGraphResponse) String() string { return proto.CompactTextString(m) }
func (*DeregisterGraphResponse) ProtoMessage()    {}
func (*DeregisterGraphResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{9}
}
func (m *DeregisterGraphResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DeregisterGraphResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DeregisterGraphResponse.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 *DeregisterGraphResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeregisterGraphResponse.Merge(m, src)
}
func (m *DeregisterGraphResponse) XXX_Size() int {
	return m.Size()
}
func (m *DeregisterGraphResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeregisterGraphResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeregisterGraphResponse proto.InternalMessageInfo

type CleanupAllRequest struct {
	// A list of container names.
	//
	// If 'container' is not empty, releases resources in the given
	// containers in all devices.
	//
	// If 'container' is empty, releases resources in the default
	// container in all devices.
	Container []string `protobuf:"bytes,1,rep,name=container,proto3" json:"container,omitempty"`
}

func (m *CleanupAllRequest) Reset()         { *m = CleanupAllRequest{} }
func (m *CleanupAllRequest) String() string { return proto.CompactTextString(m) }
func (*CleanupAllRequest) ProtoMessage()    {}
func (*CleanupAllRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{10}
}
func (m *CleanupAllRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CleanupAllRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CleanupAllRequest.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 *CleanupAllRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CleanupAllRequest.Merge(m, src)
}
func (m *CleanupAllRequest) XXX_Size() int {
	return m.Size()
}
func (m *CleanupAllRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CleanupAllRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CleanupAllRequest proto.InternalMessageInfo

func (m *CleanupAllRequest) GetContainer() []string {
	if m != nil {
		return m.Container
	}
	return nil
}

type CleanupAllResponse struct {
}

func (m *CleanupAllResponse) Reset()         { *m = CleanupAllResponse{} }
func (m *CleanupAllResponse) String() string { return proto.CompactTextString(m) }
func (*CleanupAllResponse) ProtoMessage()    {}
func (*CleanupAllResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{11}
}
func (m *CleanupAllResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CleanupAllResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CleanupAllResponse.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 *CleanupAllResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CleanupAllResponse.Merge(m, src)
}
func (m *CleanupAllResponse) XXX_Size() int {
	return m.Size()
}
func (m *CleanupAllResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CleanupAllResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CleanupAllResponse proto.InternalMessageInfo

// Options specific to the execution of a single step.
type ExecutorOpts struct {
	RecordCosts                    bool `protobuf:"varint,1,opt,name=record_costs,json=recordCosts,proto3" json:"record_costs,omitempty"`
	RecordTimeline                 bool `protobuf:"varint,3,opt,name=record_timeline,json=recordTimeline,proto3" json:"record_timeline,omitempty"`
	RecordPartitionGraphs          bool `protobuf:"varint,4,opt,name=record_partition_graphs,json=recordPartitionGraphs,proto3" json:"record_partition_graphs,omitempty"`
	ReportTensorAllocationsUponOom bool `protobuf:"varint,5,opt,name=report_tensor_allocations_upon_oom,json=reportTensorAllocationsUponOom,proto3" json:"report_tensor_allocations_upon_oom,omitempty"`
}

func (m *ExecutorOpts) Reset()         { *m = ExecutorOpts{} }
func (m *ExecutorOpts) String() string { return proto.CompactTextString(m) }
func (*ExecutorOpts) ProtoMessage()    {}
func (*ExecutorOpts) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{12}
}
func (m *ExecutorOpts) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ExecutorOpts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ExecutorOpts.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 *ExecutorOpts) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecutorOpts.Merge(m, src)
}
func (m *ExecutorOpts) XXX_Size() int {
	return m.Size()
}
func (m *ExecutorOpts) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecutorOpts.DiscardUnknown(m)
}

var xxx_messageInfo_ExecutorOpts proto.InternalMessageInfo

func (m *ExecutorOpts) GetRecordCosts() bool {
	if m != nil {
		return m.RecordCosts
	}
	return false
}

func (m *ExecutorOpts) GetRecordTimeline() bool {
	if m != nil {
		return m.RecordTimeline
	}
	return false
}

func (m *ExecutorOpts) GetRecordPartitionGraphs() bool {
	if m != nil {
		return m.RecordPartitionGraphs
	}
	return false
}

func (m *ExecutorOpts) GetReportTensorAllocationsUponOom() bool {
	if m != nil {
		return m.ReportTensorAllocationsUponOom
	}
	return false
}

type RunGraphRequest struct {
	// session_handle is the master-generated unique id for this session.
	// If session_handle is non-empty, it must be the same as used when
	// registering the graph. If it is empty, a single global namespace is used to
	// search for the graph_handle.
	SessionHandle string `protobuf:"bytes,8,opt,name=session_handle,json=sessionHandle,proto3" json:"session_handle,omitempty"`
	// Set to true if `CreateWorkerSession` was called for `session_handle`.
	CreateWorkerSessionCalled bool `protobuf:"varint,10,opt,name=create_worker_session_called,json=createWorkerSessionCalled,proto3" json:"create_worker_session_called,omitempty"`
	// REQUIRED: graph_handle must be returned by a RegisterGraph call
	// to the same WorkerService.
	GraphHandle string `protobuf:"bytes,1,opt,name=graph_handle,json=graphHandle,proto3" json:"graph_handle,omitempty"`
	// A unique ID to distinguish different runs of the same graph.
	//
	// The master generates a global unique `step_id` to distinguish
	// different runs of the graph computation. Subgraphs communicate
	// (e.g., send/recv ops) with each other using `step_id` to
	// distinguish tensors generated by different runs.
	StepId int64 `protobuf:"varint,2,opt,name=step_id,json=stepId,proto3" json:"step_id,omitempty"`
	// Options for this step.
	ExecOpts *ExecutorOpts `protobuf:"bytes,5,opt,name=exec_opts,json=execOpts,proto3" json:"exec_opts,omitempty"`
	// Runs the graph.
	//
	// Sends the tensors in "send" into the graph before the run and
	// fetches the keys into `RunGraphResponse.recv` after the run.
	Send    []*NamedTensorProto `protobuf:"bytes,3,rep,name=send,proto3" json:"send,omitempty"`
	RecvKey []string            `protobuf:"bytes,4,rep,name=recv_key,json=recvKey,proto3" json:"recv_key,omitempty"`
	// True if the RunGraphRequest is a partial run request.
	IsPartial bool `protobuf:"varint,6,opt,name=is_partial,json=isPartial,proto3" json:"is_partial,omitempty"`
	// True if this is the last partial run request in a sequence of requests.
	IsLastPartialRun bool `protobuf:"varint,7,opt,name=is_last_partial_run,json=isLastPartialRun,proto3" json:"is_last_partial_run,omitempty"`
	// If true then some errors, e.g., execution errors that have long
	// error messages, may return an OK RunGraphResponse with the actual
	// error saved in the status_code/status_error_message fields of the
	// response body. This is a workaround since the RPC subsystem may
	// truncate long metadata messages.
	StoreErrorsInResponseBody bool `protobuf:"varint,9,opt,name=store_errors_in_response_body,json=storeErrorsInResponseBody,proto3" json:"store_errors_in_response_body,omitempty"`
}

func (m *RunGraphRequest) Reset()         { *m = RunGraphRequest{} }
func (m *RunGraphRequest) String() string { return proto.CompactTextString(m) }
func (*RunGraphRequest) ProtoMessage()    {}
func (*RunGraphRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{13}
}
func (m *RunGraphRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RunGraphRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RunGraphRequest.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 *RunGraphRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunGraphRequest.Merge(m, src)
}
func (m *RunGraphRequest) XXX_Size() int {
	return m.Size()
}
func (m *RunGraphRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RunGraphRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RunGraphRequest proto.InternalMessageInfo

func (m *RunGraphRequest) GetSessionHandle() string {
	if m != nil {
		return m.SessionHandle
	}
	return ""
}

func (m *RunGraphRequest) GetCreateWorkerSessionCalled() bool {
	if m != nil {
		return m.CreateWorkerSessionCalled
	}
	return false
}

func (m *RunGraphRequest) GetGraphHandle() string {
	if m != nil {
		return m.GraphHandle
	}
	return ""
}

func (m *RunGraphRequest) GetStepId() int64 {
	if m != nil {
		return m.StepId
	}
	return 0
}

func (m *RunGraphRequest) GetExecOpts() *ExecutorOpts {
	if m != nil {
		return m.ExecOpts
	}
	return nil
}

func (m *RunGraphRequest) GetSend() []*NamedTensorProto {
	if m != nil {
		return m.Send
	}
	return nil
}

func (m *RunGraphRequest) GetRecvKey() []string {
	if m != nil {
		return m.RecvKey
	}
	return nil
}

func (m *RunGraphRequest) GetIsPartial() bool {
	if m != nil {
		return m.IsPartial
	}
	return false
}

func (m *RunGraphRequest) GetIsLastPartialRun() bool {
	if m != nil {
		return m.IsLastPartialRun
	}
	return false
}

func (m *RunGraphRequest) GetStoreErrorsInResponseBody() bool {
	if m != nil {
		return m.StoreErrorsInResponseBody
	}
	return false
}

type RunGraphResponse struct {
	// A list of tensors corresponding to those requested by
	// `RunGraphRequest.recv_key`.
	Recv []*NamedTensorProto `protobuf:"bytes,1,rep,name=recv,proto3" json:"recv,omitempty"`
	// If the request asked for execution stats, the cost graph, or the partition
	// graphs, these are returned here.
	// TODO(suharshs): Package these in a RunMetadata instead.
	StepStats      *StepStats    `protobuf:"bytes,2,opt,name=step_stats,json=stepStats,proto3" json:"step_stats,omitempty"`
	CostGraph      *CostGraphDef `protobuf:"bytes,3,opt,name=cost_graph,json=costGraph,proto3" json:"cost_graph,omitempty"`
	PartitionGraph []*GraphDef   `protobuf:"bytes,4,rep,name=partition_graph,json=partitionGraph,proto3" json:"partition_graph,omitempty"`
	// If store_errors_in_response_body is true in the request, then
	// optionally the server may return an OK status for the RPC and
	// fill the true status into the fields below, to allow for messages
	// that are too long to fit in metadata.
	StatusCode         Code   `protobuf:"varint,5,opt,name=status_code,json=statusCode,proto3,enum=tensorflow.error.Code" json:"status_code,omitempty"`
	StatusErrorMessage string `protobuf:"bytes,6,opt,name=status_error_message,json=statusErrorMessage,proto3" json:"status_error_message,omitempty"`
}

func (m *RunGraphResponse) Reset()         { *m = RunGraphResponse{} }
func (m *RunGraphResponse) String() string { return proto.CompactTextString(m) }
func (*RunGraphResponse) ProtoMessage()    {}
func (*RunGraphResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{14}
}
func (m *RunGraphResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RunGraphResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RunGraphResponse.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 *RunGraphResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RunGraphResponse.Merge(m, src)
}
func (m *RunGraphResponse) XXX_Size() int {
	return m.Size()
}
func (m *RunGraphResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RunGraphResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RunGraphResponse proto.InternalMessageInfo

func (m *RunGraphResponse) GetRecv() []*NamedTensorProto {
	if m != nil {
		return m.Recv
	}
	return nil
}

func (m *RunGraphResponse) GetStepStats() *StepStats {
	if m != nil {
		return m.StepStats
	}
	return nil
}

func (m *RunGraphResponse) GetCostGraph() *CostGraphDef {
	if m != nil {
		return m.CostGraph
	}
	return nil
}

func (m *RunGraphResponse) GetPartitionGraph() []*GraphDef {
	if m != nil {
		return m.PartitionGraph
	}
	return nil
}

func (m *RunGraphResponse) GetStatusCode() Code {
	if m != nil {
		return m.StatusCode
	}
	return Code_OK
}

func (m *RunGraphResponse) GetStatusErrorMessage() string {
	if m != nil {
		return m.StatusErrorMessage
	}
	return ""
}

type CleanupGraphRequest struct {
	StepId int64 `protobuf:"varint,1,opt,name=step_id,json=stepId,proto3" json:"step_id,omitempty"`
}

func (m *CleanupGraphRequest) Reset()         { *m = CleanupGraphRequest{} }
func (m *CleanupGraphRequest) String() string { return proto.CompactTextString(m) }
func (*CleanupGraphRequest) ProtoMessage()    {}
func (*CleanupGraphRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{15}
}
func (m *CleanupGraphRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CleanupGraphRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CleanupGraphRequest.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 *CleanupGraphRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CleanupGraphRequest.Merge(m, src)
}
func (m *CleanupGraphRequest) XXX_Size() int {
	return m.Size()
}
func (m *CleanupGraphRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CleanupGraphRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CleanupGraphRequest proto.InternalMessageInfo

func (m *CleanupGraphRequest) GetStepId() int64 {
	if m != nil {
		return m.StepId
	}
	return 0
}

type CleanupGraphResponse struct {
}

func (m *CleanupGraphResponse) Reset()         { *m = CleanupGraphResponse{} }
func (m *CleanupGraphResponse) String() string { return proto.CompactTextString(m) }
func (*CleanupGraphResponse) ProtoMessage()    {}
func (*CleanupGraphResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{16}
}
func (m *CleanupGraphResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CleanupGraphResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CleanupGraphResponse.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 *CleanupGraphResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CleanupGraphResponse.Merge(m, src)
}
func (m *CleanupGraphResponse) XXX_Size() int {
	return m.Size()
}
func (m *CleanupGraphResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CleanupGraphResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CleanupGraphResponse proto.InternalMessageInfo

type RecvTensorRequest struct {
	// The step in which the tensor will be produced.
	//
	// REQUIRED: This must eventually correspond to the `step_id` passed
	// into a RunGraph call on the same WorkerService.
	StepId int64 `protobuf:"varint,1,opt,name=step_id,json=stepId,proto3" json:"step_id,omitempty"`
	// A key identifying the channel to receive tensors from. A RecvTensor request
	// retrieves one tensor from the channel, but multiple tensors can be sent and
	// received over the same channel with multiple RecvTensor requests. See
	// rendezvous.h for details.
	RendezvousKey string `protobuf:"bytes,2,opt,name=rendezvous_key,json=rendezvousKey,proto3" json:"rendezvous_key,omitempty"`
	// If true, use an out-of-band DMA mechanism to transfer the
	// received tensor.
	DmaOk bool `protobuf:"varint,3,opt,name=dma_ok,json=dmaOk,proto3" json:"dma_ok,omitempty"`
	// Optional information on client-side device locality.
	ClientLocality *DeviceLocality `protobuf:"bytes,4,opt,name=client_locality,json=clientLocality,proto3" json:"client_locality,omitempty"`
	// Optional information on server-side device locality.
	ServerLocality *DeviceLocality `protobuf:"bytes,5,opt,name=server_locality,json=serverLocality,proto3" json:"server_locality,omitempty"`
	// Optional information needed by the RPC subsystem.
	TransportOptions *types.Any `protobuf:"bytes,6,opt,name=transport_options,json=transportOptions,proto3" json:"transport_options,omitempty"`
	// Unique identifier for this request. Every RecvTensorRequest must have a
	// unique request_id, and retried RecvTensorRequests must have the same
	// request_id. If request_id is zero, retry detection is disabled.
	//
	// Retried RecvTensorRequests are problematic because a RecvTensor with no
	// corresponding sender will wait forever, and the tensor may have been
	// delivered to a previous retry. Workers use request_ids to reject retried
	// RecvTensor requests instead of waiting forever.
	RequestId int64 `protobuf:"varint,7,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
}

func (m *RecvTensorRequest) Reset()         { *m = RecvTensorRequest{} }
func (m *RecvTensorRequest) String() string { return proto.CompactTextString(m) }
func (*RecvTensorRequest) ProtoMessage()    {}
func (*RecvTensorRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{17}
}
func (m *RecvTensorRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RecvTensorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RecvTensorRequest.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 *RecvTensorRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RecvTensorRequest.Merge(m, src)
}
func (m *RecvTensorRequest) XXX_Size() int {
	return m.Size()
}
func (m *RecvTensorRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RecvTensorRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RecvTensorRequest proto.InternalMessageInfo

func (m *RecvTensorRequest) GetStepId() int64 {
	if m != nil {
		return m.StepId
	}
	return 0
}

func (m *RecvTensorRequest) GetRendezvousKey() string {
	if m != nil {
		return m.RendezvousKey
	}
	return ""
}

func (m *RecvTensorRequest) GetDmaOk() bool {
	if m != nil {
		return m.DmaOk
	}
	return false
}

func (m *RecvTensorRequest) GetClientLocality() *DeviceLocality {
	if m != nil {
		return m.ClientLocality
	}
	return nil
}

func (m *RecvTensorRequest) GetServerLocality() *DeviceLocality {
	if m != nil {
		return m.ServerLocality
	}
	return nil
}

func (m *RecvTensorRequest) GetTransportOptions() *types.Any {
	if m != nil {
		return m.TransportOptions
	}
	return nil
}

func (m *RecvTensorRequest) GetRequestId() int64 {
	if m != nil {
		return m.RequestId
	}
	return 0
}

type RecvTensorResponse struct {
	// The tensor as a proto.
	Tensor *TensorProto `protobuf:"bytes,1,opt,name=tensor,proto3" json:"tensor,omitempty"`
	// If true, this tensor was the output of a dead node, and the
	// content is invalid.
	IsDead bool `protobuf:"varint,2,opt,name=is_dead,json=isDead,proto3" json:"is_dead,omitempty"`
	// The time at which tensor was available and started to be returned.
	SendStartMicros int64 `protobuf:"varint,3,opt,name=send_start_micros,json=sendStartMicros,proto3" json:"send_start_micros,omitempty"`
	// Optional additional information about how to receive the tensor,
	// e.g. in the event that `RecvTensorRequest.dma_ok` was true.
	TransportOptions *types.Any `protobuf:"bytes,4,opt,name=transport_options,json=transportOptions,proto3" json:"transport_options,omitempty"`
}

func (m *RecvTensorResponse) Reset()         { *m = RecvTensorResponse{} }
func (m *RecvTensorResponse) String() string { return proto.CompactTextString(m) }
func (*RecvTensorResponse) ProtoMessage()    {}
func (*RecvTensorResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{18}
}
func (m *RecvTensorResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RecvTensorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RecvTensorResponse.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 *RecvTensorResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RecvTensorResponse.Merge(m, src)
}
func (m *RecvTensorResponse) XXX_Size() int {
	return m.Size()
}
func (m *RecvTensorResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RecvTensorResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RecvTensorResponse proto.InternalMessageInfo

func (m *RecvTensorResponse) GetTensor() *TensorProto {
	if m != nil {
		return m.Tensor
	}
	return nil
}

func (m *RecvTensorResponse) GetIsDead() bool {
	if m != nil {
		return m.IsDead
	}
	return false
}

func (m *RecvTensorResponse) GetSendStartMicros() int64 {
	if m != nil {
		return m.SendStartMicros
	}
	return 0
}

func (m *RecvTensorResponse) GetTransportOptions() *types.Any {
	if m != nil {
		return m.TransportOptions
	}
	return nil
}

// Out-of-band request to begin or end logging, or
// to retrieve logs for particular steps.
type LoggingRequest struct {
	// If true, RPC logging will be enabled.
	EnableRpcLogging bool `protobuf:"varint,1,opt,name=enable_rpc_logging,json=enableRpcLogging,proto3" json:"enable_rpc_logging,omitempty"`
	// If true, RPC logging will be disabled.
	DisableRpcLogging bool `protobuf:"varint,4,opt,name=disable_rpc_logging,json=disableRpcLogging,proto3" json:"disable_rpc_logging,omitempty"`
	// If true, discard any saved logging data (for all steps).
	Clear bool `protobuf:"varint,2,opt,name=clear,proto3" json:"clear,omitempty"`
	// When set, requests all saved log data pertaining to the step.
	// Any log data retrieved is eliminated from the store and cannot be
	// retrieved again.
	FetchStepId []int64 `protobuf:"varint,3,rep,packed,name=fetch_step_id,json=fetchStepId,proto3" json:"fetch_step_id,omitempty"`
}

func (m *LoggingRequest) Reset()         { *m = LoggingRequest{} }
func (m *LoggingRequest) String() string { return proto.CompactTextString(m) }
func (*LoggingRequest) ProtoMessage()    {}
func (*LoggingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{19}
}
func (m *LoggingRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LoggingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LoggingRequest.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 *LoggingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoggingRequest.Merge(m, src)
}
func (m *LoggingRequest) XXX_Size() int {
	return m.Size()
}
func (m *LoggingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_LoggingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_LoggingRequest proto.InternalMessageInfo

func (m *LoggingRequest) GetEnableRpcLogging() bool {
	if m != nil {
		return m.EnableRpcLogging
	}
	return false
}

func (m *LoggingRequest) GetDisableRpcLogging() bool {
	if m != nil {
		return m.DisableRpcLogging
	}
	return false
}

func (m *LoggingRequest) GetClear() bool {
	if m != nil {
		return m.Clear
	}
	return false
}

func (m *LoggingRequest) GetFetchStepId() []int64 {
	if m != nil {
		return m.FetchStepId
	}
	return nil
}

type LabeledStepStats struct {
	StepId    int64      `protobuf:"varint,1,opt,name=step_id,json=stepId,proto3" json:"step_id,omitempty"`
	StepStats *StepStats `protobuf:"bytes,2,opt,name=step_stats,json=stepStats,proto3" json:"step_stats,omitempty"`
}

func (m *LabeledStepStats) Reset()         { *m = LabeledStepStats{} }
func (m *LabeledStepStats) String() string { return proto.CompactTextString(m) }
func (*LabeledStepStats) ProtoMessage()    {}
func (*LabeledStepStats) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{20}
}
func (m *LabeledStepStats) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LabeledStepStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LabeledStepStats.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 *LabeledStepStats) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LabeledStepStats.Merge(m, src)
}
func (m *LabeledStepStats) XXX_Size() int {
	return m.Size()
}
func (m *LabeledStepStats) XXX_DiscardUnknown() {
	xxx_messageInfo_LabeledStepStats.DiscardUnknown(m)
}

var xxx_messageInfo_LabeledStepStats proto.InternalMessageInfo

func (m *LabeledStepStats) GetStepId() int64 {
	if m != nil {
		return m.StepId
	}
	return 0
}

func (m *LabeledStepStats) GetStepStats() *StepStats {
	if m != nil {
		return m.StepStats
	}
	return nil
}

type LoggingResponse struct {
	Step []*LabeledStepStats `protobuf:"bytes,1,rep,name=step,proto3" json:"step,omitempty"`
}

func (m *LoggingResponse) Reset()         { *m = LoggingResponse{} }
func (m *LoggingResponse) String() string { return proto.CompactTextString(m) }
func (*LoggingResponse) ProtoMessage()    {}
func (*LoggingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{21}
}
func (m *LoggingResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LoggingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LoggingResponse.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 *LoggingResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LoggingResponse.Merge(m, src)
}
func (m *LoggingResponse) XXX_Size() int {
	return m.Size()
}
func (m *LoggingResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_LoggingResponse.DiscardUnknown(m)
}

var xxx_messageInfo_LoggingResponse proto.InternalMessageInfo

func (m *LoggingResponse) GetStep() []*LabeledStepStats {
	if m != nil {
		return m.Step
	}
	return nil
}

type TraceOpts struct {
	// Length of the trace to be taken, in seconds.
	Duration float64 `protobuf:"fixed64,1,opt,name=duration,proto3" json:"duration,omitempty"`
	// If true, capture step profile locally in each worker. Currently
	// unimplemented.
	UseStepProfiler bool `protobuf:"varint,2,opt,name=use_step_profiler,json=useStepProfiler,proto3" json:"use_step_profiler,omitempty"`
	// If true, capture kernel events from each worker.
	UseKernelProfiler bool `protobuf:"varint,3,opt,name=use_kernel_profiler,json=useKernelProfiler,proto3" json:"use_kernel_profiler,omitempty"`
	// If true, capture extended profiling events from TensorFlow process.
	UseExtendedProfiler bool `protobuf:"varint,4,opt,name=use_extended_profiler,json=useExtendedProfiler,proto3" json:"use_extended_profiler,omitempty"`
	// If true, capture GPU profiling events locally on each
	// machine. Currently unimplemented.
	UseGpuProfiler bool `protobuf:"varint,5,opt,name=use_gpu_profiler,json=useGpuProfiler,proto3" json:"use_gpu_profiler,omitempty"`
	// If true, collect sampled profile events. Currently unimplemented.
	UseSampleProfiler bool `protobuf:"varint,6,opt,name=use_sample_profiler,json=useSampleProfiler,proto3" json:"use_sample_profiler,omitempty"`
}

func (m *TraceOpts) Reset()         { *m = TraceOpts{} }
func (m *TraceOpts) String() string { return proto.CompactTextString(m) }
func (*TraceOpts) ProtoMessage()    {}
func (*TraceOpts) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{22}
}
func (m *TraceOpts) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TraceOpts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TraceOpts.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 *TraceOpts) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TraceOpts.Merge(m, src)
}
func (m *TraceOpts) XXX_Size() int {
	return m.Size()
}
func (m *TraceOpts) XXX_DiscardUnknown() {
	xxx_messageInfo_TraceOpts.DiscardUnknown(m)
}

var xxx_messageInfo_TraceOpts proto.InternalMessageInfo

func (m *TraceOpts) GetDuration() float64 {
	if m != nil {
		return m.Duration
	}
	return 0
}

func (m *TraceOpts) GetUseStepProfiler() bool {
	if m != nil {
		return m.UseStepProfiler
	}
	return false
}

func (m *TraceOpts) GetUseKernelProfiler() bool {
	if m != nil {
		return m.UseKernelProfiler
	}
	return false
}

func (m *TraceOpts) GetUseExtendedProfiler() bool {
	if m != nil {
		return m.UseExtendedProfiler
	}
	return false
}

func (m *TraceOpts) GetUseGpuProfiler() bool {
	if m != nil {
		return m.UseGpuProfiler
	}
	return false
}

func (m *TraceOpts) GetUseSampleProfiler() bool {
	if m != nil {
		return m.UseSampleProfiler
	}
	return false
}

// Out-of-band request to configure distributed tracing.
type TracingRequest struct {
	Options *TraceOpts `protobuf:"bytes,1,opt,name=options,proto3" json:"options,omitempty"`
}

func (m *TracingRequest) Reset()         { *m = TracingRequest{} }
func (m *TracingRequest) String() string { return proto.CompactTextString(m) }
func (*TracingRequest) ProtoMessage()    {}
func (*TracingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{23}
}
func (m *TracingRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracingRequest.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 *TracingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracingRequest.Merge(m, src)
}
func (m *TracingRequest) XXX_Size() int {
	return m.Size()
}
func (m *TracingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TracingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TracingRequest proto.InternalMessageInfo

func (m *TracingRequest) GetOptions() *TraceOpts {
	if m != nil {
		return m.Options
	}
	return nil
}

type TracingResponse struct {
}

func (m *TracingResponse) Reset()         { *m = TracingResponse{} }
func (m *TracingResponse) String() string { return proto.CompactTextString(m) }
func (*TracingResponse) ProtoMessage()    {}
func (*TracingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{24}
}
func (m *TracingResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TracingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TracingResponse.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 *TracingResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TracingResponse.Merge(m, src)
}
func (m *TracingResponse) XXX_Size() int {
	return m.Size()
}
func (m *TracingResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TracingResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TracingResponse proto.InternalMessageInfo

type RecvBufRequest struct {
	// Used at server side to find the correct BufRendezvous.
	StepId int64 `protobuf:"varint,1,opt,name=step_id,json=stepId,proto3" json:"step_id,omitempty"`
	// Arbitrary string identifying a BufRendezvous entry.
	BufRendezvousKey string `protobuf:"bytes,2,opt,name=buf_rendezvous_key,json=bufRendezvousKey,proto3" json:"buf_rendezvous_key,omitempty"`
	// Size of value expected, must agree with BufRendezvous entry.
	NumBytes int64 `protobuf:"varint,3,opt,name=num_bytes,json=numBytes,proto3" json:"num_bytes,omitempty"`
	// When RDMA is in use, address of destination field on client.
	BufPtr uint64 `protobuf:"fixed64,4,opt,name=buf_ptr,json=bufPtr,proto3" json:"buf_ptr,omitempty"`
	// Optional information on client-side device locality.
	ClientLocality *DeviceLocality `protobuf:"bytes,5,opt,name=client_locality,json=clientLocality,proto3" json:"client_locality,omitempty"`
	// Optional information on server-side device locality.
	ServerLocality *DeviceLocality `protobuf:"bytes,6,opt,name=server_locality,json=serverLocality,proto3" json:"server_locality,omitempty"`
	// Optional, implementation-specific data.
	TransportOptions *types.Any `protobuf:"bytes,7,opt,name=transport_options,json=transportOptions,proto3" json:"transport_options,omitempty"`
	// Optional, for annotating the timeline.
	SrcDevice string `protobuf:"bytes,8,opt,name=src_device,json=srcDevice,proto3" json:"src_device,omitempty"`
	DstDevice string `protobuf:"bytes,9,opt,name=dst_device,json=dstDevice,proto3" json:"dst_device,omitempty"`
	// Depending on the RPC system in use, it may be necessary to set this
	// id to detect resends of RPCs where the server is not aware that
	// the prior RPC failed.
	RequestId int64 `protobuf:"varint,10,opt,name=request_id,json=requestId,proto3" json:"request_id,omitempty"`
}

func (m *RecvBufRequest) Reset()         { *m = RecvBufRequest{} }
func (m *RecvBufRequest) String() string { return proto.CompactTextString(m) }
func (*RecvBufRequest) ProtoMessage()    {}
func (*RecvBufRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{25}
}
func (m *RecvBufRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RecvBufRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RecvBufRequest.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 *RecvBufRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RecvBufRequest.Merge(m, src)
}
func (m *RecvBufRequest) XXX_Size() int {
	return m.Size()
}
func (m *RecvBufRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RecvBufRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RecvBufRequest proto.InternalMessageInfo

func (m *RecvBufRequest) GetStepId() int64 {
	if m != nil {
		return m.StepId
	}
	return 0
}

func (m *RecvBufRequest) GetBufRendezvousKey() string {
	if m != nil {
		return m.BufRendezvousKey
	}
	return ""
}

func (m *RecvBufRequest) GetNumBytes() int64 {
	if m != nil {
		return m.NumBytes
	}
	return 0
}

func (m *RecvBufRequest) GetBufPtr() uint64 {
	if m != nil {
		return m.BufPtr
	}
	return 0
}

func (m *RecvBufRequest) GetClientLocality() *DeviceLocality {
	if m != nil {
		return m.ClientLocality
	}
	return nil
}

func (m *RecvBufRequest) GetServerLocality() *DeviceLocality {
	if m != nil {
		return m.ServerLocality
	}
	return nil
}

func (m *RecvBufRequest) GetTransportOptions() *types.Any {
	if m != nil {
		return m.TransportOptions
	}
	return nil
}

func (m *RecvBufRequest) GetSrcDevice() string {
	if m != nil {
		return m.SrcDevice
	}
	return ""
}

func (m *RecvBufRequest) GetDstDevice() string {
	if m != nil {
		return m.DstDevice
	}
	return ""
}

func (m *RecvBufRequest) GetRequestId() int64 {
	if m != nil {
		return m.RequestId
	}
	return 0
}

type RecvBufResponse struct {
	BufPtr   uint64 `protobuf:"fixed64,1,opt,name=buf_ptr,json=bufPtr,proto3" json:"buf_ptr,omitempty"`
	NumBytes int64  `protobuf:"varint,2,opt,name=num_bytes,json=numBytes,proto3" json:"num_bytes,omitempty"`
	IsDead   bool   `protobuf:"varint,3,opt,name=is_dead,json=isDead,proto3" json:"is_dead,omitempty"`
	// Optional, implementation-specific data.
	TransportOptions *types.Any `protobuf:"bytes,4,opt,name=transport_options,json=transportOptions,proto3" json:"transport_options,omitempty"`
	// Optional, for timeline.
	SendStartMicros int64 `protobuf:"varint,5,opt,name=send_start_micros,json=sendStartMicros,proto3" json:"send_start_micros,omitempty"`
}

func (m *RecvBufResponse) Reset()         { *m = RecvBufResponse{} }
func (m *RecvBufResponse) String() string { return proto.CompactTextString(m) }
func (*RecvBufResponse) ProtoMessage()    {}
func (*RecvBufResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{26}
}
func (m *RecvBufResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RecvBufResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RecvBufResponse.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 *RecvBufResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RecvBufResponse.Merge(m, src)
}
func (m *RecvBufResponse) XXX_Size() int {
	return m.Size()
}
func (m *RecvBufResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RecvBufResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RecvBufResponse proto.InternalMessageInfo

func (m *RecvBufResponse) GetBufPtr() uint64 {
	if m != nil {
		return m.BufPtr
	}
	return 0
}

func (m *RecvBufResponse) GetNumBytes() int64 {
	if m != nil {
		return m.NumBytes
	}
	return 0
}

func (m *RecvBufResponse) GetIsDead() bool {
	if m != nil {
		return m.IsDead
	}
	return false
}

func (m *RecvBufResponse) GetTransportOptions() *types.Any {
	if m != nil {
		return m.TransportOptions
	}
	return nil
}

func (m *RecvBufResponse) GetSendStartMicros() int64 {
	if m != nil {
		return m.SendStartMicros
	}
	return 0
}

// Supplies one or more device names as members of the group identified by
// group_key.  Service will respond when all group_size devices become known.
// All devices in group must have same type.
type CompleteGroupRequest struct {
	GroupKey   int32    `protobuf:"varint,1,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"`
	GroupSize  int32    `protobuf:"varint,2,opt,name=group_size,json=groupSize,proto3" json:"group_size,omitempty"`
	DeviceType string   `protobuf:"bytes,3,opt,name=device_type,json=deviceType,proto3" json:"device_type,omitempty"`
	DeviceName []string `protobuf:"bytes,4,rep,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
}

func (m *CompleteGroupRequest) Reset()         { *m = CompleteGroupRequest{} }
func (m *CompleteGroupRequest) String() string { return proto.CompactTextString(m) }
func (*CompleteGroupRequest) ProtoMessage()    {}
func (*CompleteGroupRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{27}
}
func (m *CompleteGroupRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompleteGroupRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompleteGroupRequest.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 *CompleteGroupRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompleteGroupRequest.Merge(m, src)
}
func (m *CompleteGroupRequest) XXX_Size() int {
	return m.Size()
}
func (m *CompleteGroupRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CompleteGroupRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CompleteGroupRequest proto.InternalMessageInfo

func (m *CompleteGroupRequest) GetGroupKey() int32 {
	if m != nil {
		return m.GroupKey
	}
	return 0
}

func (m *CompleteGroupRequest) GetGroupSize() int32 {
	if m != nil {
		return m.GroupSize
	}
	return 0
}

func (m *CompleteGroupRequest) GetDeviceType() string {
	if m != nil {
		return m.DeviceType
	}
	return ""
}

func (m *CompleteGroupRequest) GetDeviceName() []string {
	if m != nil {
		return m.DeviceName
	}
	return nil
}

// Gives the complete membership of the group identified by group_key.
type CompleteGroupResponse struct {
	GroupKey   int32    `protobuf:"varint,1,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"`
	GroupSize  int32    `protobuf:"varint,2,opt,name=group_size,json=groupSize,proto3" json:"group_size,omitempty"`
	DeviceType string   `protobuf:"bytes,3,opt,name=device_type,json=deviceType,proto3" json:"device_type,omitempty"`
	NumTasks   int32    `protobuf:"varint,4,opt,name=num_tasks,json=numTasks,proto3" json:"num_tasks,omitempty"`
	DeviceName []string `protobuf:"bytes,5,rep,name=device_name,json=deviceName,proto3" json:"device_name,omitempty"`
	TaskName   []string `protobuf:"bytes,6,rep,name=task_name,json=taskName,proto3" json:"task_name,omitempty"`
}

func (m *CompleteGroupResponse) Reset()         { *m = CompleteGroupResponse{} }
func (m *CompleteGroupResponse) String() string { return proto.CompactTextString(m) }
func (*CompleteGroupResponse) ProtoMessage()    {}
func (*CompleteGroupResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{28}
}
func (m *CompleteGroupResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompleteGroupResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompleteGroupResponse.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 *CompleteGroupResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompleteGroupResponse.Merge(m, src)
}
func (m *CompleteGroupResponse) XXX_Size() int {
	return m.Size()
}
func (m *CompleteGroupResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CompleteGroupResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CompleteGroupResponse proto.InternalMessageInfo

func (m *CompleteGroupResponse) GetGroupKey() int32 {
	if m != nil {
		return m.GroupKey
	}
	return 0
}

func (m *CompleteGroupResponse) GetGroupSize() int32 {
	if m != nil {
		return m.GroupSize
	}
	return 0
}

func (m *CompleteGroupResponse) GetDeviceType() string {
	if m != nil {
		return m.DeviceType
	}
	return ""
}

func (m *CompleteGroupResponse) GetNumTasks() int32 {
	if m != nil {
		return m.NumTasks
	}
	return 0
}

func (m *CompleteGroupResponse) GetDeviceName() []string {
	if m != nil {
		return m.DeviceName
	}
	return nil
}

func (m *CompleteGroupResponse) GetTaskName() []string {
	if m != nil {
		return m.TaskName
	}
	return nil
}

// Supplies data about one collective op belonging to the instance identified
// by instance_key.  Service will respond when all group_size ops have
// become known.  Most of the data being sent is for correctness checking,
// to ensure that all ops in the instance share common attributes.
type CompleteInstanceRequest struct {
	Name         string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Type         int32             `protobuf:"varint,2,opt,name=type,proto3" json:"type,omitempty"`
	DataType     DataType          `protobuf:"varint,3,opt,name=data_type,json=dataType,proto3,enum=tensorflow.DataType" json:"data_type,omitempty"`
	Shape        *TensorShapeProto `protobuf:"bytes,4,opt,name=shape,proto3" json:"shape,omitempty"`
	GroupKey     int32             `protobuf:"varint,5,opt,name=group_key,json=groupKey,proto3" json:"group_key,omitempty"`
	GroupSize    int32             `protobuf:"varint,6,opt,name=group_size,json=groupSize,proto3" json:"group_size,omitempty"`
	InstanceKey  int32             `protobuf:"varint,7,opt,name=instance_key,json=instanceKey,proto3" json:"instance_key,omitempty"`
	DeviceType   string            `protobuf:"bytes,8,opt,name=device_type,json=deviceType,proto3" json:"device_type,omitempty"`
	SubdivOffset []int32           `protobuf:"varint,9,rep,packed,name=subdiv_offset,json=subdivOffset,proto3" json:"subdiv_offset,omitempty"`
	Device       string            `protobuf:"bytes,10,opt,name=device,proto3" json:"device,omitempty"`
	IsSource     bool              `protobuf:"varint,11,opt,name=is_source,json=isSource,proto3" json:"is_source,omitempty"`
}

func (m *CompleteInstanceRequest) Reset()         { *m = CompleteInstanceRequest{} }
func (m *CompleteInstanceRequest) String() string { return proto.CompactTextString(m) }
func (*CompleteInstanceRequest) ProtoMessage()    {}
func (*CompleteInstanceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{29}
}
func (m *CompleteInstanceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompleteInstanceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompleteInstanceRequest.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 *CompleteInstanceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompleteInstanceRequest.Merge(m, src)
}
func (m *CompleteInstanceRequest) XXX_Size() int {
	return m.Size()
}
func (m *CompleteInstanceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CompleteInstanceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CompleteInstanceRequest proto.InternalMessageInfo

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

func (m *CompleteInstanceRequest) GetType() int32 {
	if m != nil {
		return m.Type
	}
	return 0
}

func (m *CompleteInstanceRequest) GetDataType() DataType {
	if m != nil {
		return m.DataType
	}
	return DataType_DT_INVALID
}

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

func (m *CompleteInstanceRequest) GetGroupKey() int32 {
	if m != nil {
		return m.GroupKey
	}
	return 0
}

func (m *CompleteInstanceRequest) GetGroupSize() int32 {
	if m != nil {
		return m.GroupSize
	}
	return 0
}

func (m *CompleteInstanceRequest) GetInstanceKey() int32 {
	if m != nil {
		return m.InstanceKey
	}
	return 0
}

func (m *CompleteInstanceRequest) GetDeviceType() string {
	if m != nil {
		return m.DeviceType
	}
	return ""
}

func (m *CompleteInstanceRequest) GetSubdivOffset() []int32 {
	if m != nil {
		return m.SubdivOffset
	}
	return nil
}

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

func (m *CompleteInstanceRequest) GetIsSource() bool {
	if m != nil {
		return m.IsSource
	}
	return false
}

// Confirms that every op in the instance has consistently declared itself.
// Also gives the source_rank in case of broadcast.
type CompleteInstanceResponse struct {
	InstanceKey int32 `protobuf:"varint,1,opt,name=instance_key,json=instanceKey,proto3" json:"instance_key,omitempty"`
	SourceRank  int32 `protobuf:"varint,2,opt,name=source_rank,json=sourceRank,proto3" json:"source_rank,omitempty"`
}

func (m *CompleteInstanceResponse) Reset()         { *m = CompleteInstanceResponse{} }
func (m *CompleteInstanceResponse) String() string { return proto.CompactTextString(m) }
func (*CompleteInstanceResponse) ProtoMessage()    {}
func (*CompleteInstanceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{30}
}
func (m *CompleteInstanceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CompleteInstanceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CompleteInstanceResponse.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 *CompleteInstanceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CompleteInstanceResponse.Merge(m, src)
}
func (m *CompleteInstanceResponse) XXX_Size() int {
	return m.Size()
}
func (m *CompleteInstanceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CompleteInstanceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CompleteInstanceResponse proto.InternalMessageInfo

func (m *CompleteInstanceResponse) GetInstanceKey() int32 {
	if m != nil {
		return m.InstanceKey
	}
	return 0
}

func (m *CompleteInstanceResponse) GetSourceRank() int32 {
	if m != nil {
		return m.SourceRank
	}
	return 0
}

// Request for next agreed-upon step_id for the specified graph_keys.
// This is used to enable multiple graphs containing nodes from
// a common collective instance to coordinate using the same step_ids.
type GetStepSequenceRequest struct {
	GraphKey []int64 `protobuf:"varint,1,rep,packed,name=graph_key,json=graphKey,proto3" json:"graph_key,omitempty"`
}

func (m *GetStepSequenceRequest) Reset()         { *m = GetStepSequenceRequest{} }
func (m *GetStepSequenceRequest) String() string { return proto.CompactTextString(m) }
func (*GetStepSequenceRequest) ProtoMessage()    {}
func (*GetStepSequenceRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{31}
}
func (m *GetStepSequenceRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetStepSequenceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetStepSequenceRequest.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 *GetStepSequenceRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetStepSequenceRequest.Merge(m, src)
}
func (m *GetStepSequenceRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetStepSequenceRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetStepSequenceRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetStepSequenceRequest proto.InternalMessageInfo

func (m *GetStepSequenceRequest) GetGraphKey() []int64 {
	if m != nil {
		return m.GraphKey
	}
	return nil
}

type StepSequence struct {
	GraphKey   int64 `protobuf:"varint,1,opt,name=graph_key,json=graphKey,proto3" json:"graph_key,omitempty"`
	NextStepId int64 `protobuf:"varint,2,opt,name=next_step_id,json=nextStepId,proto3" json:"next_step_id,omitempty"`
}

func (m *StepSequence) Reset()         { *m = StepSequence{} }
func (m *StepSequence) String() string { return proto.CompactTextString(m) }
func (*StepSequence) ProtoMessage()    {}
func (*StepSequence) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{32}
}
func (m *StepSequence) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StepSequence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StepSequence.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 *StepSequence) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StepSequence.Merge(m, src)
}
func (m *StepSequence) XXX_Size() int {
	return m.Size()
}
func (m *StepSequence) XXX_DiscardUnknown() {
	xxx_messageInfo_StepSequence.DiscardUnknown(m)
}

var xxx_messageInfo_StepSequence proto.InternalMessageInfo

func (m *StepSequence) GetGraphKey() int64 {
	if m != nil {
		return m.GraphKey
	}
	return 0
}

func (m *StepSequence) GetNextStepId() int64 {
	if m != nil {
		return m.NextStepId
	}
	return 0
}

// Next valid step_ids for one or more graph_keys.
type GetStepSequenceResponse struct {
	StepSequence []*StepSequence `protobuf:"bytes,1,rep,name=step_sequence,json=stepSequence,proto3" json:"step_sequence,omitempty"`
}

func (m *GetStepSequenceResponse) Reset()         { *m = GetStepSequenceResponse{} }
func (m *GetStepSequenceResponse) String() string { return proto.CompactTextString(m) }
func (*GetStepSequenceResponse) ProtoMessage()    {}
func (*GetStepSequenceResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e4ff6184b07e587a, []int{33}
}
func (m *GetStepSequenceResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetStepSequenceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetStepSequenceResponse.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 *GetStepSequenceResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetStepSequenceResponse.Merge(m, src)
}
func (m *GetStepSequenceResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetStepSequenceResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetStepSequenceResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetStepSequenceResponse proto.InternalMessageInfo

func (m *GetStepSequenceResponse) GetStepSequence() []*StepSequence {
	if m != nil {
		return m.StepSequence
	}
	return nil
}

func init() {
	proto.RegisterType((*GetStatusRequest)(nil), "tensorflow.GetStatusRequest")
	proto.RegisterType((*GetStatusResponse)(nil), "tensorflow.GetStatusResponse")
	proto.RegisterType((*CreateWorkerSessionRequest)(nil), "tensorflow.CreateWorkerSessionRequest")
	proto.RegisterType((*CreateWorkerSessionResponse)(nil), "tensorflow.CreateWorkerSessionResponse")
	proto.RegisterType((*DeleteWorkerSessionRequest)(nil), "tensorflow.DeleteWorkerSessionRequest")
	proto.RegisterType((*DeleteWorkerSessionResponse)(nil), "tensorflow.DeleteWorkerSessionResponse")
	proto.RegisterType((*RegisterGraphRequest)(nil), "tensorflow.RegisterGraphRequest")
	proto.RegisterType((*RegisterGraphResponse)(nil), "tensorflow.RegisterGraphResponse")
	proto.RegisterType((*DeregisterGraphRequest)(nil), "tensorflow.DeregisterGraphRequest")
	proto.RegisterType((*DeregisterGraphResponse)(nil), "tensorflow.DeregisterGraphResponse")
	proto.RegisterType((*CleanupAllRequest)(nil), "tensorflow.CleanupAllRequest")
	proto.RegisterType((*CleanupAllResponse)(nil), "tensorflow.CleanupAllResponse")
	proto.RegisterType((*ExecutorOpts)(nil), "tensorflow.ExecutorOpts")
	proto.RegisterType((*RunGraphRequest)(nil), "tensorflow.RunGraphRequest")
	proto.RegisterType((*RunGraphResponse)(nil), "tensorflow.RunGraphResponse")
	proto.RegisterType((*CleanupGraphRequest)(nil), "tensorflow.CleanupGraphRequest")
	proto.RegisterType((*CleanupGraphResponse)(nil), "tensorflow.CleanupGraphResponse")
	proto.RegisterType((*RecvTensorRequest)(nil), "tensorflow.RecvTensorRequest")
	proto.RegisterType((*RecvTensorResponse)(nil), "tensorflow.RecvTensorResponse")
	proto.RegisterType((*LoggingRequest)(nil), "tensorflow.LoggingRequest")
	proto.RegisterType((*LabeledStepStats)(nil), "tensorflow.LabeledStepStats")
	proto.RegisterType((*LoggingResponse)(nil), "tensorflow.LoggingResponse")
	proto.RegisterType((*TraceOpts)(nil), "tensorflow.TraceOpts")
	proto.RegisterType((*TracingRequest)(nil), "tensorflow.TracingRequest")
	proto.RegisterType((*TracingResponse)(nil), "tensorflow.TracingResponse")
	proto.RegisterType((*RecvBufRequest)(nil), "tensorflow.RecvBufRequest")
	proto.RegisterType((*RecvBufResponse)(nil), "tensorflow.RecvBufResponse")
	proto.RegisterType((*CompleteGroupRequest)(nil), "tensorflow.CompleteGroupRequest")
	proto.RegisterType((*CompleteGroupResponse)(nil), "tensorflow.CompleteGroupResponse")
	proto.RegisterType((*CompleteInstanceRequest)(nil), "tensorflow.CompleteInstanceRequest")
	proto.RegisterType((*CompleteInstanceResponse)(nil), "tensorflow.CompleteInstanceResponse")
	proto.RegisterType((*GetStepSequenceRequest)(nil), "tensorflow.GetStepSequenceRequest")
	proto.RegisterType((*StepSequence)(nil), "tensorflow.StepSequence")
	proto.RegisterType((*GetStepSequenceResponse)(nil), "tensorflow.GetStepSequenceResponse")
}

func init() { proto.RegisterFile("worker.proto", fileDescriptor_e4ff6184b07e587a) }

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

func (m *GetStatusRequest) 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 *GetStatusRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *GetStatusResponse) 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 *GetStatusResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.DeviceAttributes) > 0 {
		for _, msg := range m.DeviceAttributes {
			dAtA[i] = 0xa
			i++
			i = encodeVarintWorker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *CreateWorkerSessionRequest) 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 *CreateWorkerSessionRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.SessionHandle) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.SessionHandle)))
		i += copy(dAtA[i:], m.SessionHandle)
	}
	if m.ServerDef != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.ServerDef.Size()))
		n1, err1 := m.ServerDef.MarshalTo(dAtA[i:])
		if err1 != nil {
			return 0, err1
		}
		i += n1
	}
	if m.IsolateSessionState {
		dAtA[i] = 0x18
		i++
		if m.IsolateSessionState {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *CreateWorkerSessionResponse) 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 *CreateWorkerSessionResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *DeleteWorkerSessionRequest) 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 *DeleteWorkerSessionRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.SessionHandle) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.SessionHandle)))
		i += copy(dAtA[i:], m.SessionHandle)
	}
	return i, nil
}

func (m *DeleteWorkerSessionResponse) 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 *DeleteWorkerSessionResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *RegisterGraphRequest) 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 *RegisterGraphRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.SessionHandle) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.SessionHandle)))
		i += copy(dAtA[i:], m.SessionHandle)
	}
	if m.GraphDef != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GraphDef.Size()))
		n2, err2 := m.GraphDef.MarshalTo(dAtA[i:])
		if err2 != nil {
			return 0, err2
		}
		i += n2
	}
	if m.HasControlFlow {
		dAtA[i] = 0x18
		i++
		if m.HasControlFlow {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.GraphOptions != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GraphOptions.Size()))
		n3, err3 := m.GraphOptions.MarshalTo(dAtA[i:])
		if err3 != nil {
			return 0, err3
		}
		i += n3
	}
	if m.DebugOptions != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.DebugOptions.Size()))
		n4, err4 := m.DebugOptions.MarshalTo(dAtA[i:])
		if err4 != nil {
			return 0, err4
		}
		i += n4
	}
	if m.CreateWorkerSessionCalled {
		dAtA[i] = 0x30
		i++
		if m.CreateWorkerSessionCalled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.CollectiveGraphKey != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.CollectiveGraphKey))
	}
	return i, nil
}

func (m *RegisterGraphResponse) 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 *RegisterGraphResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.GraphHandle) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.GraphHandle)))
		i += copy(dAtA[i:], m.GraphHandle)
	}
	return i, nil
}

func (m *DeregisterGraphRequest) 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 *DeregisterGraphRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.GraphHandle) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.GraphHandle)))
		i += copy(dAtA[i:], m.GraphHandle)
	}
	if len(m.SessionHandle) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.SessionHandle)))
		i += copy(dAtA[i:], m.SessionHandle)
	}
	if m.CreateWorkerSessionCalled {
		dAtA[i] = 0x18
		i++
		if m.CreateWorkerSessionCalled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *DeregisterGraphResponse) 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 *DeregisterGraphResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *CleanupAllRequest) 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 *CleanupAllRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Container) > 0 {
		for _, s := range m.Container {
			dAtA[i] = 0xa
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *CleanupAllResponse) 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 *CleanupAllResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *ExecutorOpts) 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 *ExecutorOpts) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RecordCosts {
		dAtA[i] = 0x8
		i++
		if m.RecordCosts {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.RecordTimeline {
		dAtA[i] = 0x18
		i++
		if m.RecordTimeline {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.RecordPartitionGraphs {
		dAtA[i] = 0x20
		i++
		if m.RecordPartitionGraphs {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.ReportTensorAllocationsUponOom {
		dAtA[i] = 0x28
		i++
		if m.ReportTensorAllocationsUponOom {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *RunGraphRequest) 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 *RunGraphRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.GraphHandle) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.GraphHandle)))
		i += copy(dAtA[i:], m.GraphHandle)
	}
	if m.StepId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.StepId))
	}
	if len(m.Send) > 0 {
		for _, msg := range m.Send {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintWorker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.RecvKey) > 0 {
		for _, s := range m.RecvKey {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if m.ExecOpts != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.ExecOpts.Size()))
		n5, err5 := m.ExecOpts.MarshalTo(dAtA[i:])
		if err5 != nil {
			return 0, err5
		}
		i += n5
	}
	if m.IsPartial {
		dAtA[i] = 0x30
		i++
		if m.IsPartial {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.IsLastPartialRun {
		dAtA[i] = 0x38
		i++
		if m.IsLastPartialRun {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.SessionHandle) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.SessionHandle)))
		i += copy(dAtA[i:], m.SessionHandle)
	}
	if m.StoreErrorsInResponseBody {
		dAtA[i] = 0x48
		i++
		if m.StoreErrorsInResponseBody {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.CreateWorkerSessionCalled {
		dAtA[i] = 0x50
		i++
		if m.CreateWorkerSessionCalled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *RunGraphResponse) 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 *RunGraphResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Recv) > 0 {
		for _, msg := range m.Recv {
			dAtA[i] = 0xa
			i++
			i = encodeVarintWorker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.StepStats != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.StepStats.Size()))
		n6, err6 := m.StepStats.MarshalTo(dAtA[i:])
		if err6 != nil {
			return 0, err6
		}
		i += n6
	}
	if m.CostGraph != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.CostGraph.Size()))
		n7, err7 := m.CostGraph.MarshalTo(dAtA[i:])
		if err7 != nil {
			return 0, err7
		}
		i += n7
	}
	if len(m.PartitionGraph) > 0 {
		for _, msg := range m.PartitionGraph {
			dAtA[i] = 0x22
			i++
			i = encodeVarintWorker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.StatusCode != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.StatusCode))
	}
	if len(m.StatusErrorMessage) > 0 {
		dAtA[i] = 0x32
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.StatusErrorMessage)))
		i += copy(dAtA[i:], m.StatusErrorMessage)
	}
	return i, nil
}

func (m *CleanupGraphRequest) 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 *CleanupGraphRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StepId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.StepId))
	}
	return i, nil
}

func (m *CleanupGraphResponse) 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 *CleanupGraphResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *RecvTensorRequest) 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 *RecvTensorRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StepId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.StepId))
	}
	if len(m.RendezvousKey) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.RendezvousKey)))
		i += copy(dAtA[i:], m.RendezvousKey)
	}
	if m.DmaOk {
		dAtA[i] = 0x18
		i++
		if m.DmaOk {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.ClientLocality != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.ClientLocality.Size()))
		n8, err8 := m.ClientLocality.MarshalTo(dAtA[i:])
		if err8 != nil {
			return 0, err8
		}
		i += n8
	}
	if m.ServerLocality != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.ServerLocality.Size()))
		n9, err9 := m.ServerLocality.MarshalTo(dAtA[i:])
		if err9 != nil {
			return 0, err9
		}
		i += n9
	}
	if m.TransportOptions != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.TransportOptions.Size()))
		n10, err10 := m.TransportOptions.MarshalTo(dAtA[i:])
		if err10 != nil {
			return 0, err10
		}
		i += n10
	}
	if m.RequestId != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.RequestId))
	}
	return i, nil
}

func (m *RecvTensorResponse) 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 *RecvTensorResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Tensor != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.Tensor.Size()))
		n11, err11 := m.Tensor.MarshalTo(dAtA[i:])
		if err11 != nil {
			return 0, err11
		}
		i += n11
	}
	if m.IsDead {
		dAtA[i] = 0x10
		i++
		if m.IsDead {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.SendStartMicros != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.SendStartMicros))
	}
	if m.TransportOptions != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.TransportOptions.Size()))
		n12, err12 := m.TransportOptions.MarshalTo(dAtA[i:])
		if err12 != nil {
			return 0, err12
		}
		i += n12
	}
	return i, nil
}

func (m *LoggingRequest) 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 *LoggingRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.EnableRpcLogging {
		dAtA[i] = 0x8
		i++
		if m.EnableRpcLogging {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Clear {
		dAtA[i] = 0x10
		i++
		if m.Clear {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.FetchStepId) > 0 {
		dAtA14 := make([]byte, len(m.FetchStepId)*10)
		var j13 int
		for _, num1 := range m.FetchStepId {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA14[j13] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j13++
			}
			dAtA14[j13] = uint8(num)
			j13++
		}
		dAtA[i] = 0x1a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(j13))
		i += copy(dAtA[i:], dAtA14[:j13])
	}
	if m.DisableRpcLogging {
		dAtA[i] = 0x20
		i++
		if m.DisableRpcLogging {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *LabeledStepStats) 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 *LabeledStepStats) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StepId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.StepId))
	}
	if m.StepStats != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.StepStats.Size()))
		n15, err15 := m.StepStats.MarshalTo(dAtA[i:])
		if err15 != nil {
			return 0, err15
		}
		i += n15
	}
	return i, nil
}

func (m *LoggingResponse) 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 *LoggingResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Step) > 0 {
		for _, msg := range m.Step {
			dAtA[i] = 0xa
			i++
			i = encodeVarintWorker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *TraceOpts) 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 *TraceOpts) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Duration != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Duration))))
		i += 8
	}
	if m.UseStepProfiler {
		dAtA[i] = 0x10
		i++
		if m.UseStepProfiler {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.UseKernelProfiler {
		dAtA[i] = 0x18
		i++
		if m.UseKernelProfiler {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.UseExtendedProfiler {
		dAtA[i] = 0x20
		i++
		if m.UseExtendedProfiler {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.UseGpuProfiler {
		dAtA[i] = 0x28
		i++
		if m.UseGpuProfiler {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.UseSampleProfiler {
		dAtA[i] = 0x30
		i++
		if m.UseSampleProfiler {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *TracingRequest) 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 *TracingRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Options != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.Options.Size()))
		n16, err16 := m.Options.MarshalTo(dAtA[i:])
		if err16 != nil {
			return 0, err16
		}
		i += n16
	}
	return i, nil
}

func (m *TracingResponse) 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 *TracingResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *RecvBufRequest) 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 *RecvBufRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StepId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.StepId))
	}
	if len(m.BufRendezvousKey) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.BufRendezvousKey)))
		i += copy(dAtA[i:], m.BufRendezvousKey)
	}
	if m.NumBytes != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.NumBytes))
	}
	if m.BufPtr != 0 {
		dAtA[i] = 0x21
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.BufPtr))
		i += 8
	}
	if m.ClientLocality != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.ClientLocality.Size()))
		n17, err17 := m.ClientLocality.MarshalTo(dAtA[i:])
		if err17 != nil {
			return 0, err17
		}
		i += n17
	}
	if m.ServerLocality != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.ServerLocality.Size()))
		n18, err18 := m.ServerLocality.MarshalTo(dAtA[i:])
		if err18 != nil {
			return 0, err18
		}
		i += n18
	}
	if m.TransportOptions != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.TransportOptions.Size()))
		n19, err19 := m.TransportOptions.MarshalTo(dAtA[i:])
		if err19 != nil {
			return 0, err19
		}
		i += n19
	}
	if len(m.SrcDevice) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.SrcDevice)))
		i += copy(dAtA[i:], m.SrcDevice)
	}
	if len(m.DstDevice) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.DstDevice)))
		i += copy(dAtA[i:], m.DstDevice)
	}
	if m.RequestId != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.RequestId))
	}
	return i, nil
}

func (m *RecvBufResponse) 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 *RecvBufResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.BufPtr != 0 {
		dAtA[i] = 0x9
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.BufPtr))
		i += 8
	}
	if m.NumBytes != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.NumBytes))
	}
	if m.IsDead {
		dAtA[i] = 0x18
		i++
		if m.IsDead {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.TransportOptions != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.TransportOptions.Size()))
		n20, err20 := m.TransportOptions.MarshalTo(dAtA[i:])
		if err20 != nil {
			return 0, err20
		}
		i += n20
	}
	if m.SendStartMicros != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.SendStartMicros))
	}
	return i, nil
}

func (m *CompleteGroupRequest) 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 *CompleteGroupRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.GroupKey != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GroupKey))
	}
	if m.GroupSize != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GroupSize))
	}
	if len(m.DeviceType) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.DeviceType)))
		i += copy(dAtA[i:], m.DeviceType)
	}
	if len(m.DeviceName) > 0 {
		for _, s := range m.DeviceName {
			dAtA[i] = 0x22
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *CompleteGroupResponse) 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 *CompleteGroupResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.GroupKey != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GroupKey))
	}
	if m.GroupSize != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GroupSize))
	}
	if len(m.DeviceType) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.DeviceType)))
		i += copy(dAtA[i:], m.DeviceType)
	}
	if m.NumTasks != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.NumTasks))
	}
	if len(m.DeviceName) > 0 {
		for _, s := range m.DeviceName {
			dAtA[i] = 0x2a
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	if len(m.TaskName) > 0 {
		for _, s := range m.TaskName {
			dAtA[i] = 0x32
			i++
			l = len(s)
			for l >= 1<<7 {
				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
				l >>= 7
				i++
			}
			dAtA[i] = uint8(l)
			i++
			i += copy(dAtA[i:], s)
		}
	}
	return i, nil
}

func (m *CompleteInstanceRequest) 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 *CompleteInstanceRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if m.Type != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.Type))
	}
	if m.DataType != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.DataType))
	}
	if m.Shape != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.Shape.Size()))
		n21, err21 := m.Shape.MarshalTo(dAtA[i:])
		if err21 != nil {
			return 0, err21
		}
		i += n21
	}
	if m.GroupKey != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GroupKey))
	}
	if m.GroupSize != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GroupSize))
	}
	if m.InstanceKey != 0 {
		dAtA[i] = 0x38
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.InstanceKey))
	}
	if len(m.DeviceType) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.DeviceType)))
		i += copy(dAtA[i:], m.DeviceType)
	}
	if len(m.SubdivOffset) > 0 {
		dAtA23 := make([]byte, len(m.SubdivOffset)*10)
		var j22 int
		for _, num1 := range m.SubdivOffset {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA23[j22] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j22++
			}
			dAtA23[j22] = uint8(num)
			j22++
		}
		dAtA[i] = 0x4a
		i++
		i = encodeVarintWorker(dAtA, i, uint64(j22))
		i += copy(dAtA[i:], dAtA23[:j22])
	}
	if len(m.Device) > 0 {
		dAtA[i] = 0x52
		i++
		i = encodeVarintWorker(dAtA, i, uint64(len(m.Device)))
		i += copy(dAtA[i:], m.Device)
	}
	if m.IsSource {
		dAtA[i] = 0x58
		i++
		if m.IsSource {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *CompleteInstanceResponse) 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 *CompleteInstanceResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.InstanceKey != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.InstanceKey))
	}
	if m.SourceRank != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.SourceRank))
	}
	return i, nil
}

func (m *GetStepSequenceRequest) 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 *GetStepSequenceRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.GraphKey) > 0 {
		dAtA25 := make([]byte, len(m.GraphKey)*10)
		var j24 int
		for _, num1 := range m.GraphKey {
			num := uint64(num1)
			for num >= 1<<7 {
				dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j24++
			}
			dAtA25[j24] = uint8(num)
			j24++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintWorker(dAtA, i, uint64(j24))
		i += copy(dAtA[i:], dAtA25[:j24])
	}
	return i, nil
}

func (m *StepSequence) 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 *StepSequence) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.GraphKey != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.GraphKey))
	}
	if m.NextStepId != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintWorker(dAtA, i, uint64(m.NextStepId))
	}
	return i, nil
}

func (m *GetStepSequenceResponse) 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 *GetStepSequenceResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.StepSequence) > 0 {
		for _, msg := range m.StepSequence {
			dAtA[i] = 0xa
			i++
			i = encodeVarintWorker(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func encodeVarintWorker(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 *GetStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

func (m *CreateWorkerSessionRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SessionHandle)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.ServerDef != nil {
		l = m.ServerDef.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.IsolateSessionState {
		n += 2
	}
	return n
}

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

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

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

func (m *RegisterGraphRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SessionHandle)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.GraphDef != nil {
		l = m.GraphDef.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.HasControlFlow {
		n += 2
	}
	if m.GraphOptions != nil {
		l = m.GraphOptions.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.DebugOptions != nil {
		l = m.DebugOptions.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.CreateWorkerSessionCalled {
		n += 2
	}
	if m.CollectiveGraphKey != 0 {
		n += 1 + sovWorker(uint64(m.CollectiveGraphKey))
	}
	return n
}

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

func (m *DeregisterGraphRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GraphHandle)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	l = len(m.SessionHandle)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.CreateWorkerSessionCalled {
		n += 2
	}
	return n
}

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

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

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

func (m *ExecutorOpts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RecordCosts {
		n += 2
	}
	if m.RecordTimeline {
		n += 2
	}
	if m.RecordPartitionGraphs {
		n += 2
	}
	if m.ReportTensorAllocationsUponOom {
		n += 2
	}
	return n
}

func (m *RunGraphRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.GraphHandle)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.StepId != 0 {
		n += 1 + sovWorker(uint64(m.StepId))
	}
	if len(m.Send) > 0 {
		for _, e := range m.Send {
			l = e.Size()
			n += 1 + l + sovWorker(uint64(l))
		}
	}
	if len(m.RecvKey) > 0 {
		for _, s := range m.RecvKey {
			l = len(s)
			n += 1 + l + sovWorker(uint64(l))
		}
	}
	if m.ExecOpts != nil {
		l = m.ExecOpts.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.IsPartial {
		n += 2
	}
	if m.IsLastPartialRun {
		n += 2
	}
	l = len(m.SessionHandle)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.StoreErrorsInResponseBody {
		n += 2
	}
	if m.CreateWorkerSessionCalled {
		n += 2
	}
	return n
}

func (m *RunGraphResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Recv) > 0 {
		for _, e := range m.Recv {
			l = e.Size()
			n += 1 + l + sovWorker(uint64(l))
		}
	}
	if m.StepStats != nil {
		l = m.StepStats.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.CostGraph != nil {
		l = m.CostGraph.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if len(m.PartitionGraph) > 0 {
		for _, e := range m.PartitionGraph {
			l = e.Size()
			n += 1 + l + sovWorker(uint64(l))
		}
	}
	if m.StatusCode != 0 {
		n += 1 + sovWorker(uint64(m.StatusCode))
	}
	l = len(m.StatusErrorMessage)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	return n
}

func (m *CleanupGraphRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StepId != 0 {
		n += 1 + sovWorker(uint64(m.StepId))
	}
	return n
}

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

func (m *RecvTensorRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StepId != 0 {
		n += 1 + sovWorker(uint64(m.StepId))
	}
	l = len(m.RendezvousKey)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.DmaOk {
		n += 2
	}
	if m.ClientLocality != nil {
		l = m.ClientLocality.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.ServerLocality != nil {
		l = m.ServerLocality.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.TransportOptions != nil {
		l = m.TransportOptions.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.RequestId != 0 {
		n += 1 + sovWorker(uint64(m.RequestId))
	}
	return n
}

func (m *RecvTensorResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tensor != nil {
		l = m.Tensor.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.IsDead {
		n += 2
	}
	if m.SendStartMicros != 0 {
		n += 1 + sovWorker(uint64(m.SendStartMicros))
	}
	if m.TransportOptions != nil {
		l = m.TransportOptions.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	return n
}

func (m *LoggingRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.EnableRpcLogging {
		n += 2
	}
	if m.Clear {
		n += 2
	}
	if len(m.FetchStepId) > 0 {
		l = 0
		for _, e := range m.FetchStepId {
			l += sovWorker(uint64(e))
		}
		n += 1 + sovWorker(uint64(l)) + l
	}
	if m.DisableRpcLogging {
		n += 2
	}
	return n
}

func (m *LabeledStepStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StepId != 0 {
		n += 1 + sovWorker(uint64(m.StepId))
	}
	if m.StepStats != nil {
		l = m.StepStats.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	return n
}

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

func (m *TraceOpts) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Duration != 0 {
		n += 9
	}
	if m.UseStepProfiler {
		n += 2
	}
	if m.UseKernelProfiler {
		n += 2
	}
	if m.UseExtendedProfiler {
		n += 2
	}
	if m.UseGpuProfiler {
		n += 2
	}
	if m.UseSampleProfiler {
		n += 2
	}
	return n
}

func (m *TracingRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Options != nil {
		l = m.Options.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	return n
}

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

func (m *RecvBufRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StepId != 0 {
		n += 1 + sovWorker(uint64(m.StepId))
	}
	l = len(m.BufRendezvousKey)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.NumBytes != 0 {
		n += 1 + sovWorker(uint64(m.NumBytes))
	}
	if m.BufPtr != 0 {
		n += 9
	}
	if m.ClientLocality != nil {
		l = m.ClientLocality.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.ServerLocality != nil {
		l = m.ServerLocality.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.TransportOptions != nil {
		l = m.TransportOptions.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	l = len(m.SrcDevice)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	l = len(m.DstDevice)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.RequestId != 0 {
		n += 1 + sovWorker(uint64(m.RequestId))
	}
	return n
}

func (m *RecvBufResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BufPtr != 0 {
		n += 9
	}
	if m.NumBytes != 0 {
		n += 1 + sovWorker(uint64(m.NumBytes))
	}
	if m.IsDead {
		n += 2
	}
	if m.TransportOptions != nil {
		l = m.TransportOptions.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.SendStartMicros != 0 {
		n += 1 + sovWorker(uint64(m.SendStartMicros))
	}
	return n
}

func (m *CompleteGroupRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GroupKey != 0 {
		n += 1 + sovWorker(uint64(m.GroupKey))
	}
	if m.GroupSize != 0 {
		n += 1 + sovWorker(uint64(m.GroupSize))
	}
	l = len(m.DeviceType)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if len(m.DeviceName) > 0 {
		for _, s := range m.DeviceName {
			l = len(s)
			n += 1 + l + sovWorker(uint64(l))
		}
	}
	return n
}

func (m *CompleteGroupResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GroupKey != 0 {
		n += 1 + sovWorker(uint64(m.GroupKey))
	}
	if m.GroupSize != 0 {
		n += 1 + sovWorker(uint64(m.GroupSize))
	}
	l = len(m.DeviceType)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.NumTasks != 0 {
		n += 1 + sovWorker(uint64(m.NumTasks))
	}
	if len(m.DeviceName) > 0 {
		for _, s := range m.DeviceName {
			l = len(s)
			n += 1 + l + sovWorker(uint64(l))
		}
	}
	if len(m.TaskName) > 0 {
		for _, s := range m.TaskName {
			l = len(s)
			n += 1 + l + sovWorker(uint64(l))
		}
	}
	return n
}

func (m *CompleteInstanceRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovWorker(uint64(m.Type))
	}
	if m.DataType != 0 {
		n += 1 + sovWorker(uint64(m.DataType))
	}
	if m.Shape != nil {
		l = m.Shape.Size()
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.GroupKey != 0 {
		n += 1 + sovWorker(uint64(m.GroupKey))
	}
	if m.GroupSize != 0 {
		n += 1 + sovWorker(uint64(m.GroupSize))
	}
	if m.InstanceKey != 0 {
		n += 1 + sovWorker(uint64(m.InstanceKey))
	}
	l = len(m.DeviceType)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if len(m.SubdivOffset) > 0 {
		l = 0
		for _, e := range m.SubdivOffset {
			l += sovWorker(uint64(e))
		}
		n += 1 + sovWorker(uint64(l)) + l
	}
	l = len(m.Device)
	if l > 0 {
		n += 1 + l + sovWorker(uint64(l))
	}
	if m.IsSource {
		n += 2
	}
	return n
}

func (m *CompleteInstanceResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InstanceKey != 0 {
		n += 1 + sovWorker(uint64(m.InstanceKey))
	}
	if m.SourceRank != 0 {
		n += 1 + sovWorker(uint64(m.SourceRank))
	}
	return n
}

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

func (m *StepSequence) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.GraphKey != 0 {
		n += 1 + sovWorker(uint64(m.GraphKey))
	}
	if m.NextStepId != 0 {
		n += 1 + sovWorker(uint64(m.NextStepId))
	}
	return n
}

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

func sovWorker(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozWorker(x uint64) (n int) {
	return sovWorker(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GetStatusRequest) 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 ErrIntOverflowWorker
			}
			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: GetStatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetStatusResponse) 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 ErrIntOverflowWorker
			}
			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: GetStatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			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 := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CreateWorkerSessionRequest) 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 ErrIntOverflowWorker
			}
			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: CreateWorkerSessionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateWorkerSessionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionHandle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			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 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsolateSessionState", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsolateSessionState = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeleteWorkerSessionRequest) 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 ErrIntOverflowWorker
			}
			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: DeleteWorkerSessionRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeleteWorkerSessionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionHandle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterGraphRequest) 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 ErrIntOverflowWorker
			}
			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: RegisterGraphRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterGraphRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionHandle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GraphDef", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GraphDef == nil {
				m.GraphDef = &GraphDef{}
			}
			if err := m.GraphDef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasControlFlow", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasControlFlow = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GraphOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GraphOptions == nil {
				m.GraphOptions = &GraphOptions{}
			}
			if err := m.GraphOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DebugOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DebugOptions == nil {
				m.DebugOptions = &DebugOptions{}
			}
			if err := m.DebugOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateWorkerSessionCalled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CreateWorkerSessionCalled = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollectiveGraphKey", wireType)
			}
			m.CollectiveGraphKey = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CollectiveGraphKey |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RegisterGraphResponse) 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 ErrIntOverflowWorker
			}
			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: RegisterGraphResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegisterGraphResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GraphHandle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GraphHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeregisterGraphRequest) 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 ErrIntOverflowWorker
			}
			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: DeregisterGraphRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeregisterGraphRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GraphHandle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GraphHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionHandle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateWorkerSessionCalled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CreateWorkerSessionCalled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CleanupAllRequest) 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 ErrIntOverflowWorker
			}
			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: CleanupAllRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CleanupAllRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Container = append(m.Container, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecutorOpts) 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 ErrIntOverflowWorker
			}
			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: ExecutorOpts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecutorOpts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordCosts", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RecordCosts = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordTimeline", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RecordTimeline = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecordPartitionGraphs", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RecordPartitionGraphs = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportTensorAllocationsUponOom", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReportTensorAllocationsUponOom = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RunGraphRequest) 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 ErrIntOverflowWorker
			}
			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: RunGraphRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RunGraphRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GraphHandle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GraphHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepId", wireType)
			}
			m.StepId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StepId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Send", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Send = append(m.Send, &NamedTensorProto{})
			if err := m.Send[len(m.Send)-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 RecvKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecvKey = append(m.RecvKey, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecOpts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExecOpts == nil {
				m.ExecOpts = &ExecutorOpts{}
			}
			if err := m.ExecOpts.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsPartial", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsPartial = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsLastPartialRun", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsLastPartialRun = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionHandle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreErrorsInResponseBody", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.StoreErrorsInResponseBody = bool(v != 0)
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateWorkerSessionCalled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CreateWorkerSessionCalled = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RunGraphResponse) 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 ErrIntOverflowWorker
			}
			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: RunGraphResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RunGraphResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recv", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Recv = append(m.Recv, &NamedTensorProto{})
			if err := m.Recv[len(m.Recv)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StepStats == nil {
				m.StepStats = &StepStats{}
			}
			if err := m.StepStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CostGraph", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CostGraph == nil {
				m.CostGraph = &CostGraphDef{}
			}
			if err := m.CostGraph.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartitionGraph", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PartitionGraph = append(m.PartitionGraph, &GraphDef{})
			if err := m.PartitionGraph[len(m.PartitionGraph)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusCode", wireType)
			}
			m.StatusCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StatusCode |= Code(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusErrorMessage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StatusErrorMessage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CleanupGraphRequest) 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 ErrIntOverflowWorker
			}
			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: CleanupGraphRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CleanupGraphRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepId", wireType)
			}
			m.StepId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StepId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecvTensorRequest) 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 ErrIntOverflowWorker
			}
			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: RecvTensorRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecvTensorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepId", wireType)
			}
			m.StepId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StepId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RendezvousKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RendezvousKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DmaOk", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DmaOk = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientLocality", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClientLocality == nil {
				m.ClientLocality = &DeviceLocality{}
			}
			if err := m.ClientLocality.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerLocality", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ServerLocality == nil {
				m.ServerLocality = &DeviceLocality{}
			}
			if err := m.ServerLocality.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransportOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TransportOptions == nil {
				m.TransportOptions = &types.Any{}
			}
			if err := m.TransportOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			m.RequestId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecvTensorResponse) 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 ErrIntOverflowWorker
			}
			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: RecvTensorResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecvTensorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tensor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tensor == nil {
				m.Tensor = &TensorProto{}
			}
			if err := m.Tensor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsDead", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsDead = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendStartMicros", wireType)
			}
			m.SendStartMicros = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SendStartMicros |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransportOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TransportOptions == nil {
				m.TransportOptions = &types.Any{}
			}
			if err := m.TransportOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LoggingRequest) 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 ErrIntOverflowWorker
			}
			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: LoggingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LoggingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableRpcLogging", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableRpcLogging = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Clear", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Clear = bool(v != 0)
		case 3:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowWorker
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.FetchStepId = append(m.FetchStepId, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowWorker
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthWorker
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthWorker
				}
				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.FetchStepId) == 0 {
					m.FetchStepId = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowWorker
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.FetchStepId = append(m.FetchStepId, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field FetchStepId", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisableRpcLogging", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisableRpcLogging = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TraceOpts) 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 ErrIntOverflowWorker
			}
			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: TraceOpts: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TraceOpts: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Duration = float64(math.Float64frombits(v))
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseStepProfiler", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseStepProfiler = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseKernelProfiler", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseKernelProfiler = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseExtendedProfiler", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseExtendedProfiler = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseGpuProfiler", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseGpuProfiler = bool(v != 0)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UseSampleProfiler", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UseSampleProfiler = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecvBufRequest) 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 ErrIntOverflowWorker
			}
			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: RecvBufRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecvBufRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StepId", wireType)
			}
			m.StepId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StepId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BufRendezvousKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BufRendezvousKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumBytes", wireType)
			}
			m.NumBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field BufPtr", wireType)
			}
			m.BufPtr = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.BufPtr = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientLocality", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClientLocality == nil {
				m.ClientLocality = &DeviceLocality{}
			}
			if err := m.ClientLocality.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServerLocality", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ServerLocality == nil {
				m.ServerLocality = &DeviceLocality{}
			}
			if err := m.ServerLocality.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransportOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TransportOptions == nil {
				m.TransportOptions = &types.Any{}
			}
			if err := m.TransportOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SrcDevice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SrcDevice = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DstDevice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DstDevice = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)
			}
			m.RequestId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecvBufResponse) 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 ErrIntOverflowWorker
			}
			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: RecvBufResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecvBufResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field BufPtr", wireType)
			}
			m.BufPtr = 0
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			m.BufPtr = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumBytes", wireType)
			}
			m.NumBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsDead", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsDead = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransportOptions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TransportOptions == nil {
				m.TransportOptions = &types.Any{}
			}
			if err := m.TransportOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SendStartMicros", wireType)
			}
			m.SendStartMicros = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SendStartMicros |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompleteGroupRequest) 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 ErrIntOverflowWorker
			}
			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: CompleteGroupRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompleteGroupRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupKey", wireType)
			}
			m.GroupKey = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupKey |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupSize", wireType)
			}
			m.GroupSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceType = string(dAtA[iNdEx:postIndex])
			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 ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceName = append(m.DeviceName, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompleteGroupResponse) 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 ErrIntOverflowWorker
			}
			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: CompleteGroupResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompleteGroupResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupKey", wireType)
			}
			m.GroupKey = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupKey |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupSize", wireType)
			}
			m.GroupSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumTasks", wireType)
			}
			m.NumTasks = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumTasks |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceName = append(m.DeviceName, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TaskName = append(m.TaskName, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompleteInstanceRequest) 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 ErrIntOverflowWorker
			}
			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: CompleteInstanceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompleteInstanceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataType", wireType)
			}
			m.DataType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataType |= DataType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthWorker
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Shape == nil {
				m.Shape = &TensorShapeProto{}
			}
			if err := m.Shape.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupKey", wireType)
			}
			m.GroupKey = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupKey |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupSize", wireType)
			}
			m.GroupSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupSize |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceKey", wireType)
			}
			m.InstanceKey = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InstanceKey |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeviceType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeviceType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType == 0 {
				var v int32
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowWorker
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.SubdivOffset = append(m.SubdivOffset, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowWorker
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthWorker
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthWorker
				}
				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.SubdivOffset) == 0 {
					m.SubdivOffset = make([]int32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int32
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowWorker
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.SubdivOffset = append(m.SubdivOffset, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field SubdivOffset", wireType)
			}
		case 10:
			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 ErrIntOverflowWorker
				}
				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 ErrInvalidLengthWorker
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthWorker
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Device = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsSource", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsSource = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CompleteInstanceResponse) 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 ErrIntOverflowWorker
			}
			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: CompleteInstanceResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompleteInstanceResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceKey", wireType)
			}
			m.InstanceKey = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InstanceKey |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceRank", wireType)
			}
			m.SourceRank = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SourceRank |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetStepSequenceRequest) 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 ErrIntOverflowWorker
			}
			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: GetStepSequenceRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetStepSequenceRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 0 {
				var v int64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowWorker
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= int64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.GraphKey = append(m.GraphKey, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowWorker
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthWorker
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthWorker
				}
				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.GraphKey) == 0 {
					m.GraphKey = make([]int64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v int64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowWorker
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.GraphKey = append(m.GraphKey, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field GraphKey", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StepSequence) 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 ErrIntOverflowWorker
			}
			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: StepSequence: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StepSequence: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GraphKey", wireType)
			}
			m.GraphKey = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GraphKey |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextStepId", wireType)
			}
			m.NextStepId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowWorker
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextStepId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipWorker(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthWorker
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipWorker(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, ErrIntOverflowWorker
			}
			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, ErrIntOverflowWorker
				}
				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, ErrIntOverflowWorker
				}
				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, ErrInvalidLengthWorker
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthWorker
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowWorker
					}
					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 := skipWorker(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthWorker
				}
			}
			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 (
	ErrInvalidLengthWorker = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowWorker   = fmt.Errorf("proto: integer overflow")
)