debug.pb.go

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

package tensorflow

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	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

// Option for watching a node in TensorFlow Debugger (tfdbg).
type DebugTensorWatch struct {
	// Name of the node to watch.
	NodeName string `protobuf:"bytes,1,opt,name=node_name,json=nodeName,proto3" json:"node_name,omitempty"`
	// Output slot to watch.
	// The semantics of output_slot == -1 is that the node is only watched for
	// completion, but not for any output tensors. See NodeCompletionCallback
	// in debug_gateway.h.
	// TODO(cais): Implement this semantics.
	OutputSlot int32 `protobuf:"varint,2,opt,name=output_slot,json=outputSlot,proto3" json:"output_slot,omitempty"`
	// Name(s) of the debugging op(s).
	// One or more than one probes on a tensor.
	// e.g., {"DebugIdentity", "DebugNanCount"}
	DebugOps []string `protobuf:"bytes,3,rep,name=debug_ops,json=debugOps,proto3" json:"debug_ops,omitempty"`
	// URL(s) for debug targets(s).
	//
	// Supported URL formats are:
	//   - file:///foo/tfdbg_dump: Writes out Event content to file
	//     /foo/tfdbg_dump.  Assumes all directories can be created if they don't
	//     already exist.
	//   - grpc://localhost:11011: Sends an RPC request to an EventListener
	//     service running at localhost:11011 with the event.
	//   - memcbk:///event_key: Routes tensors to clients using the
	//     callback registered with the DebugCallbackRegistry for event_key.
	//
	// Each debug op listed in debug_ops will publish its output tensor (debug
	// signal) to all URLs in debug_urls.
	//
	// N.B. Session::Run() supports concurrent invocations of the same inputs
	// (feed keys), outputs and target nodes. If such concurrent invocations
	// are to be debugged, the callers of Session::Run() must use distinct
	// debug_urls to make sure that the streamed or dumped events do not overlap
	// among the invocations.
	// TODO(cais): More visible documentation of this in g3docs.
	DebugUrls []string `protobuf:"bytes,4,rep,name=debug_urls,json=debugUrls,proto3" json:"debug_urls,omitempty"`
	// Do not error out if debug op creation fails (e.g., due to dtype
	// incompatibility). Instead, just log the failure.
	TolerateDebugOpCreationFailures bool `protobuf:"varint,5,opt,name=tolerate_debug_op_creation_failures,json=tolerateDebugOpCreationFailures,proto3" json:"tolerate_debug_op_creation_failures,omitempty"`
}

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

var xxx_messageInfo_DebugTensorWatch proto.InternalMessageInfo

func (m *DebugTensorWatch) GetNodeName() string {
	if m != nil {
		return m.NodeName
	}
	return ""
}

func (m *DebugTensorWatch) GetOutputSlot() int32 {
	if m != nil {
		return m.OutputSlot
	}
	return 0
}

func (m *DebugTensorWatch) GetDebugOps() []string {
	if m != nil {
		return m.DebugOps
	}
	return nil
}

func (m *DebugTensorWatch) GetDebugUrls() []string {
	if m != nil {
		return m.DebugUrls
	}
	return nil
}

func (m *DebugTensorWatch) GetTolerateDebugOpCreationFailures() bool {
	if m != nil {
		return m.TolerateDebugOpCreationFailures
	}
	return false
}

// Options for initializing DebuggerState in TensorFlow Debugger (tfdbg).
type DebugOptions struct {
	// Debugging options
	DebugTensorWatchOpts []*DebugTensorWatch `protobuf:"bytes,4,rep,name=debug_tensor_watch_opts,json=debugTensorWatchOpts,proto3" json:"debug_tensor_watch_opts,omitempty"`
	// Caller-specified global step count.
	// Note that this is distinct from the session run count and the executor
	// step count.
	GlobalStep int64 `protobuf:"varint,10,opt,name=global_step,json=globalStep,proto3" json:"global_step,omitempty"`
	// Whether the total disk usage of tfdbg is to be reset to zero
	// in this Session.run call. This is used by wrappers and hooks
	// such as the local CLI ones to indicate that the dumped tensors
	// are cleaned up from the disk after each Session.run.
	ResetDiskByteUsage bool `protobuf:"varint,11,opt,name=reset_disk_byte_usage,json=resetDiskByteUsage,proto3" json:"reset_disk_byte_usage,omitempty"`
}

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

var xxx_messageInfo_DebugOptions proto.InternalMessageInfo

func (m *DebugOptions) GetDebugTensorWatchOpts() []*DebugTensorWatch {
	if m != nil {
		return m.DebugTensorWatchOpts
	}
	return nil
}

func (m *DebugOptions) GetGlobalStep() int64 {
	if m != nil {
		return m.GlobalStep
	}
	return 0
}

func (m *DebugOptions) GetResetDiskByteUsage() bool {
	if m != nil {
		return m.ResetDiskByteUsage
	}
	return false
}

type DebuggedSourceFile struct {
	// The host name on which a source code file is located.
	Host string `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	// Path to the source code file.
	FilePath string `protobuf:"bytes,2,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`
	// The timestamp at which the source code file is last modified.
	LastModified int64 `protobuf:"varint,3,opt,name=last_modified,json=lastModified,proto3" json:"last_modified,omitempty"`
	// Byte size of the file.
	Bytes int64 `protobuf:"varint,4,opt,name=bytes,proto3" json:"bytes,omitempty"`
	// Line-by-line content of the source code file.
	Lines []string `protobuf:"bytes,5,rep,name=lines,proto3" json:"lines,omitempty"`
}

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

var xxx_messageInfo_DebuggedSourceFile proto.InternalMessageInfo

func (m *DebuggedSourceFile) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}

func (m *DebuggedSourceFile) GetFilePath() string {
	if m != nil {
		return m.FilePath
	}
	return ""
}

func (m *DebuggedSourceFile) GetLastModified() int64 {
	if m != nil {
		return m.LastModified
	}
	return 0
}

func (m *DebuggedSourceFile) GetBytes() int64 {
	if m != nil {
		return m.Bytes
	}
	return 0
}

func (m *DebuggedSourceFile) GetLines() []string {
	if m != nil {
		return m.Lines
	}
	return nil
}

type DebuggedSourceFiles struct {
	// A collection of source code files.
	SourceFiles []*DebuggedSourceFile `protobuf:"bytes,1,rep,name=source_files,json=sourceFiles,proto3" json:"source_files,omitempty"`
}

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

var xxx_messageInfo_DebuggedSourceFiles proto.InternalMessageInfo

func (m *DebuggedSourceFiles) GetSourceFiles() []*DebuggedSourceFile {
	if m != nil {
		return m.SourceFiles
	}
	return nil
}

func init() {
	proto.RegisterType((*DebugTensorWatch)(nil), "tensorflow.DebugTensorWatch")
	proto.RegisterType((*DebugOptions)(nil), "tensorflow.DebugOptions")
	proto.RegisterType((*DebuggedSourceFile)(nil), "tensorflow.DebuggedSourceFile")
	proto.RegisterType((*DebuggedSourceFiles)(nil), "tensorflow.DebuggedSourceFiles")
}

func init() { proto.RegisterFile("debug.proto", fileDescriptor_8d9d361be58531fb) }

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

func (m *DebugTensorWatch) 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 *DebugTensorWatch) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NodeName) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebug(dAtA, i, uint64(len(m.NodeName)))
		i += copy(dAtA[i:], m.NodeName)
	}
	if m.OutputSlot != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDebug(dAtA, i, uint64(m.OutputSlot))
	}
	if len(m.DebugOps) > 0 {
		for _, s := range m.DebugOps {
			dAtA[i] = 0x1a
			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.DebugUrls) > 0 {
		for _, s := range m.DebugUrls {
			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.TolerateDebugOpCreationFailures {
		dAtA[i] = 0x28
		i++
		if m.TolerateDebugOpCreationFailures {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *DebugOptions) 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 *DebugOptions) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.DebugTensorWatchOpts) > 0 {
		for _, msg := range m.DebugTensorWatchOpts {
			dAtA[i] = 0x22
			i++
			i = encodeVarintDebug(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.GlobalStep != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintDebug(dAtA, i, uint64(m.GlobalStep))
	}
	if m.ResetDiskByteUsage {
		dAtA[i] = 0x58
		i++
		if m.ResetDiskByteUsage {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *DebuggedSourceFile) 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 *DebuggedSourceFile) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Host) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebug(dAtA, i, uint64(len(m.Host)))
		i += copy(dAtA[i:], m.Host)
	}
	if len(m.FilePath) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebug(dAtA, i, uint64(len(m.FilePath)))
		i += copy(dAtA[i:], m.FilePath)
	}
	if m.LastModified != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDebug(dAtA, i, uint64(m.LastModified))
	}
	if m.Bytes != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintDebug(dAtA, i, uint64(m.Bytes))
	}
	if len(m.Lines) > 0 {
		for _, s := range m.Lines {
			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)
		}
	}
	return i, nil
}

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

func encodeVarintDebug(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 *DebugTensorWatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NodeName)
	if l > 0 {
		n += 1 + l + sovDebug(uint64(l))
	}
	if m.OutputSlot != 0 {
		n += 1 + sovDebug(uint64(m.OutputSlot))
	}
	if len(m.DebugOps) > 0 {
		for _, s := range m.DebugOps {
			l = len(s)
			n += 1 + l + sovDebug(uint64(l))
		}
	}
	if len(m.DebugUrls) > 0 {
		for _, s := range m.DebugUrls {
			l = len(s)
			n += 1 + l + sovDebug(uint64(l))
		}
	}
	if m.TolerateDebugOpCreationFailures {
		n += 2
	}
	return n
}

func (m *DebugOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.DebugTensorWatchOpts) > 0 {
		for _, e := range m.DebugTensorWatchOpts {
			l = e.Size()
			n += 1 + l + sovDebug(uint64(l))
		}
	}
	if m.GlobalStep != 0 {
		n += 1 + sovDebug(uint64(m.GlobalStep))
	}
	if m.ResetDiskByteUsage {
		n += 2
	}
	return n
}

func (m *DebuggedSourceFile) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Host)
	if l > 0 {
		n += 1 + l + sovDebug(uint64(l))
	}
	l = len(m.FilePath)
	if l > 0 {
		n += 1 + l + sovDebug(uint64(l))
	}
	if m.LastModified != 0 {
		n += 1 + sovDebug(uint64(m.LastModified))
	}
	if m.Bytes != 0 {
		n += 1 + sovDebug(uint64(m.Bytes))
	}
	if len(m.Lines) > 0 {
		for _, s := range m.Lines {
			l = len(s)
			n += 1 + l + sovDebug(uint64(l))
		}
	}
	return n
}

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

func sovDebug(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozDebug(x uint64) (n int) {
	return sovDebug(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DebugTensorWatch) 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 ErrIntOverflowDebug
			}
			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: DebugTensorWatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DebugTensorWatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				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 ErrInvalidLengthDebug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDebug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputSlot", wireType)
			}
			m.OutputSlot = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OutputSlot |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DebugOps", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				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 ErrInvalidLengthDebug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDebug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DebugOps = append(m.DebugOps, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DebugUrls", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				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 ErrInvalidLengthDebug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDebug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DebugUrls = append(m.DebugUrls, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TolerateDebugOpCreationFailures", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.TolerateDebugOpCreationFailures = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipDebug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDebug
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DebugOptions) 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 ErrIntOverflowDebug
			}
			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: DebugOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DebugOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DebugTensorWatchOpts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDebug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DebugTensorWatchOpts = append(m.DebugTensorWatchOpts, &DebugTensorWatch{})
			if err := m.DebugTensorWatchOpts[len(m.DebugTensorWatchOpts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GlobalStep", wireType)
			}
			m.GlobalStep = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GlobalStep |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResetDiskByteUsage", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ResetDiskByteUsage = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipDebug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDebug
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DebuggedSourceFile) 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 ErrIntOverflowDebug
			}
			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: DebuggedSourceFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DebuggedSourceFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				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 ErrInvalidLengthDebug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDebug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Host = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FilePath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				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 ErrInvalidLengthDebug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDebug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FilePath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastModified", wireType)
			}
			m.LastModified = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastModified |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Bytes", wireType)
			}
			m.Bytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Bytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Lines", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebug
				}
				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 ErrInvalidLengthDebug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDebug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Lines = append(m.Lines, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDebug
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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