replay_log.pb.go

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

package tensorflow

import (
	encoding_binary "encoding/binary"
	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

// Records the creation of a new replay session.  We record the device listing
// here to capture the state of the cluster.
type NewReplaySession struct {
	Devices       *ListDevicesResponse `protobuf:"bytes,1,opt,name=devices,proto3" json:"devices,omitempty"`
	SessionHandle string               `protobuf:"bytes,2,opt,name=session_handle,json=sessionHandle,proto3" json:"session_handle,omitempty"`
}

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

var xxx_messageInfo_NewReplaySession proto.InternalMessageInfo

func (m *NewReplaySession) GetDevices() *ListDevicesResponse {
	if m != nil {
		return m.Devices
	}
	return nil
}

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

type ReplayOp struct {
	StartTimeUs float64 `protobuf:"fixed64,31,opt,name=start_time_us,json=startTimeUs,proto3" json:"start_time_us,omitempty"`
	EndTimeUs   float64 `protobuf:"fixed64,32,opt,name=end_time_us,json=endTimeUs,proto3" json:"end_time_us,omitempty"`
	// Types that are valid to be assigned to Op:
	//	*ReplayOp_CreateSession
	//	*ReplayOp_ExtendSession
	//	*ReplayOp_PartialRunSetup
	//	*ReplayOp_RunStep
	//	*ReplayOp_CloseSession
	//	*ReplayOp_ListDevices
	//	*ReplayOp_ResetRequest
	//	*ReplayOp_MakeCallable
	//	*ReplayOp_RunCallable
	//	*ReplayOp_ReleaseCallable
	//	*ReplayOp_NewReplaySession
	Op isReplayOp_Op `protobuf_oneof:"op"`
	// Types that are valid to be assigned to Response:
	//	*ReplayOp_CreateSessionResponse
	//	*ReplayOp_ExtendSessionResponse
	//	*ReplayOp_PartialRunSetupResponse
	//	*ReplayOp_RunStepResponse
	//	*ReplayOp_CloseSessionResponse
	//	*ReplayOp_ListDevicesResponse
	//	*ReplayOp_ResetRequestResponse
	//	*ReplayOp_MakeCallableResponse
	//	*ReplayOp_RunCallableResponse
	//	*ReplayOp_ReleaseCallableResponse
	Response isReplayOp_Response `protobuf_oneof:"response"`
}

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

var xxx_messageInfo_ReplayOp proto.InternalMessageInfo

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

type ReplayOp_CreateSession struct {
	CreateSession *CreateSessionRequest `protobuf:"bytes,1,opt,name=create_session,json=createSession,proto3,oneof"`
}
type ReplayOp_ExtendSession struct {
	ExtendSession *ExtendSessionRequest `protobuf:"bytes,2,opt,name=extend_session,json=extendSession,proto3,oneof"`
}
type ReplayOp_PartialRunSetup struct {
	PartialRunSetup *PartialRunSetupRequest `protobuf:"bytes,3,opt,name=partial_run_setup,json=partialRunSetup,proto3,oneof"`
}
type ReplayOp_RunStep struct {
	RunStep *RunStepRequest `protobuf:"bytes,4,opt,name=run_step,json=runStep,proto3,oneof"`
}
type ReplayOp_CloseSession struct {
	CloseSession *CloseSessionRequest `protobuf:"bytes,5,opt,name=close_session,json=closeSession,proto3,oneof"`
}
type ReplayOp_ListDevices struct {
	ListDevices *ListDevicesRequest `protobuf:"bytes,6,opt,name=list_devices,json=listDevices,proto3,oneof"`
}
type ReplayOp_ResetRequest struct {
	ResetRequest *ResetRequest `protobuf:"bytes,7,opt,name=reset_request,json=resetRequest,proto3,oneof"`
}
type ReplayOp_MakeCallable struct {
	MakeCallable *MakeCallableRequest `protobuf:"bytes,8,opt,name=make_callable,json=makeCallable,proto3,oneof"`
}
type ReplayOp_RunCallable struct {
	RunCallable *RunCallableRequest `protobuf:"bytes,9,opt,name=run_callable,json=runCallable,proto3,oneof"`
}
type ReplayOp_ReleaseCallable struct {
	ReleaseCallable *ReleaseCallableRequest `protobuf:"bytes,10,opt,name=release_callable,json=releaseCallable,proto3,oneof"`
}
type ReplayOp_NewReplaySession struct {
	NewReplaySession *NewReplaySession `protobuf:"bytes,11,opt,name=new_replay_session,json=newReplaySession,proto3,oneof"`
}
type ReplayOp_CreateSessionResponse struct {
	CreateSessionResponse *CreateSessionResponse `protobuf:"bytes,21,opt,name=create_session_response,json=createSessionResponse,proto3,oneof"`
}
type ReplayOp_ExtendSessionResponse struct {
	ExtendSessionResponse *ExtendSessionResponse `protobuf:"bytes,22,opt,name=extend_session_response,json=extendSessionResponse,proto3,oneof"`
}
type ReplayOp_PartialRunSetupResponse struct {
	PartialRunSetupResponse *PartialRunSetupResponse `protobuf:"bytes,23,opt,name=partial_run_setup_response,json=partialRunSetupResponse,proto3,oneof"`
}
type ReplayOp_RunStepResponse struct {
	RunStepResponse *RunStepResponse `protobuf:"bytes,24,opt,name=run_step_response,json=runStepResponse,proto3,oneof"`
}
type ReplayOp_CloseSessionResponse struct {
	CloseSessionResponse *CloseSessionResponse `protobuf:"bytes,25,opt,name=close_session_response,json=closeSessionResponse,proto3,oneof"`
}
type ReplayOp_ListDevicesResponse struct {
	ListDevicesResponse *ListDevicesResponse `protobuf:"bytes,26,opt,name=list_devices_response,json=listDevicesResponse,proto3,oneof"`
}
type ReplayOp_ResetRequestResponse struct {
	ResetRequestResponse *ResetResponse `protobuf:"bytes,27,opt,name=reset_request_response,json=resetRequestResponse,proto3,oneof"`
}
type ReplayOp_MakeCallableResponse struct {
	MakeCallableResponse *MakeCallableResponse `protobuf:"bytes,28,opt,name=make_callable_response,json=makeCallableResponse,proto3,oneof"`
}
type ReplayOp_RunCallableResponse struct {
	RunCallableResponse *RunCallableResponse `protobuf:"bytes,29,opt,name=run_callable_response,json=runCallableResponse,proto3,oneof"`
}
type ReplayOp_ReleaseCallableResponse struct {
	ReleaseCallableResponse *ReleaseCallableResponse `protobuf:"bytes,30,opt,name=release_callable_response,json=releaseCallableResponse,proto3,oneof"`
}

func (*ReplayOp_CreateSession) isReplayOp_Op()                 {}
func (*ReplayOp_ExtendSession) isReplayOp_Op()                 {}
func (*ReplayOp_PartialRunSetup) isReplayOp_Op()               {}
func (*ReplayOp_RunStep) isReplayOp_Op()                       {}
func (*ReplayOp_CloseSession) isReplayOp_Op()                  {}
func (*ReplayOp_ListDevices) isReplayOp_Op()                   {}
func (*ReplayOp_ResetRequest) isReplayOp_Op()                  {}
func (*ReplayOp_MakeCallable) isReplayOp_Op()                  {}
func (*ReplayOp_RunCallable) isReplayOp_Op()                   {}
func (*ReplayOp_ReleaseCallable) isReplayOp_Op()               {}
func (*ReplayOp_NewReplaySession) isReplayOp_Op()              {}
func (*ReplayOp_CreateSessionResponse) isReplayOp_Response()   {}
func (*ReplayOp_ExtendSessionResponse) isReplayOp_Response()   {}
func (*ReplayOp_PartialRunSetupResponse) isReplayOp_Response() {}
func (*ReplayOp_RunStepResponse) isReplayOp_Response()         {}
func (*ReplayOp_CloseSessionResponse) isReplayOp_Response()    {}
func (*ReplayOp_ListDevicesResponse) isReplayOp_Response()     {}
func (*ReplayOp_ResetRequestResponse) isReplayOp_Response()    {}
func (*ReplayOp_MakeCallableResponse) isReplayOp_Response()    {}
func (*ReplayOp_RunCallableResponse) isReplayOp_Response()     {}
func (*ReplayOp_ReleaseCallableResponse) isReplayOp_Response() {}

func (m *ReplayOp) GetOp() isReplayOp_Op {
	if m != nil {
		return m.Op
	}
	return nil
}
func (m *ReplayOp) GetResponse() isReplayOp_Response {
	if m != nil {
		return m.Response
	}
	return nil
}

func (m *ReplayOp) GetStartTimeUs() float64 {
	if m != nil {
		return m.StartTimeUs
	}
	return 0
}

func (m *ReplayOp) GetEndTimeUs() float64 {
	if m != nil {
		return m.EndTimeUs
	}
	return 0
}

func (m *ReplayOp) GetCreateSession() *CreateSessionRequest {
	if x, ok := m.GetOp().(*ReplayOp_CreateSession); ok {
		return x.CreateSession
	}
	return nil
}

func (m *ReplayOp) GetExtendSession() *ExtendSessionRequest {
	if x, ok := m.GetOp().(*ReplayOp_ExtendSession); ok {
		return x.ExtendSession
	}
	return nil
}

func (m *ReplayOp) GetPartialRunSetup() *PartialRunSetupRequest {
	if x, ok := m.GetOp().(*ReplayOp_PartialRunSetup); ok {
		return x.PartialRunSetup
	}
	return nil
}

func (m *ReplayOp) GetRunStep() *RunStepRequest {
	if x, ok := m.GetOp().(*ReplayOp_RunStep); ok {
		return x.RunStep
	}
	return nil
}

func (m *ReplayOp) GetCloseSession() *CloseSessionRequest {
	if x, ok := m.GetOp().(*ReplayOp_CloseSession); ok {
		return x.CloseSession
	}
	return nil
}

func (m *ReplayOp) GetListDevices() *ListDevicesRequest {
	if x, ok := m.GetOp().(*ReplayOp_ListDevices); ok {
		return x.ListDevices
	}
	return nil
}

func (m *ReplayOp) GetResetRequest() *ResetRequest {
	if x, ok := m.GetOp().(*ReplayOp_ResetRequest); ok {
		return x.ResetRequest
	}
	return nil
}

func (m *ReplayOp) GetMakeCallable() *MakeCallableRequest {
	if x, ok := m.GetOp().(*ReplayOp_MakeCallable); ok {
		return x.MakeCallable
	}
	return nil
}

func (m *ReplayOp) GetRunCallable() *RunCallableRequest {
	if x, ok := m.GetOp().(*ReplayOp_RunCallable); ok {
		return x.RunCallable
	}
	return nil
}

func (m *ReplayOp) GetReleaseCallable() *ReleaseCallableRequest {
	if x, ok := m.GetOp().(*ReplayOp_ReleaseCallable); ok {
		return x.ReleaseCallable
	}
	return nil
}

func (m *ReplayOp) GetNewReplaySession() *NewReplaySession {
	if x, ok := m.GetOp().(*ReplayOp_NewReplaySession); ok {
		return x.NewReplaySession
	}
	return nil
}

func (m *ReplayOp) GetCreateSessionResponse() *CreateSessionResponse {
	if x, ok := m.GetResponse().(*ReplayOp_CreateSessionResponse); ok {
		return x.CreateSessionResponse
	}
	return nil
}

func (m *ReplayOp) GetExtendSessionResponse() *ExtendSessionResponse {
	if x, ok := m.GetResponse().(*ReplayOp_ExtendSessionResponse); ok {
		return x.ExtendSessionResponse
	}
	return nil
}

func (m *ReplayOp) GetPartialRunSetupResponse() *PartialRunSetupResponse {
	if x, ok := m.GetResponse().(*ReplayOp_PartialRunSetupResponse); ok {
		return x.PartialRunSetupResponse
	}
	return nil
}

func (m *ReplayOp) GetRunStepResponse() *RunStepResponse {
	if x, ok := m.GetResponse().(*ReplayOp_RunStepResponse); ok {
		return x.RunStepResponse
	}
	return nil
}

func (m *ReplayOp) GetCloseSessionResponse() *CloseSessionResponse {
	if x, ok := m.GetResponse().(*ReplayOp_CloseSessionResponse); ok {
		return x.CloseSessionResponse
	}
	return nil
}

func (m *ReplayOp) GetListDevicesResponse() *ListDevicesResponse {
	if x, ok := m.GetResponse().(*ReplayOp_ListDevicesResponse); ok {
		return x.ListDevicesResponse
	}
	return nil
}

func (m *ReplayOp) GetResetRequestResponse() *ResetResponse {
	if x, ok := m.GetResponse().(*ReplayOp_ResetRequestResponse); ok {
		return x.ResetRequestResponse
	}
	return nil
}

func (m *ReplayOp) GetMakeCallableResponse() *MakeCallableResponse {
	if x, ok := m.GetResponse().(*ReplayOp_MakeCallableResponse); ok {
		return x.MakeCallableResponse
	}
	return nil
}

func (m *ReplayOp) GetRunCallableResponse() *RunCallableResponse {
	if x, ok := m.GetResponse().(*ReplayOp_RunCallableResponse); ok {
		return x.RunCallableResponse
	}
	return nil
}

func (m *ReplayOp) GetReleaseCallableResponse() *ReleaseCallableResponse {
	if x, ok := m.GetResponse().(*ReplayOp_ReleaseCallableResponse); ok {
		return x.ReleaseCallableResponse
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*ReplayOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _ReplayOp_OneofMarshaler, _ReplayOp_OneofUnmarshaler, _ReplayOp_OneofSizer, []interface{}{
		(*ReplayOp_CreateSession)(nil),
		(*ReplayOp_ExtendSession)(nil),
		(*ReplayOp_PartialRunSetup)(nil),
		(*ReplayOp_RunStep)(nil),
		(*ReplayOp_CloseSession)(nil),
		(*ReplayOp_ListDevices)(nil),
		(*ReplayOp_ResetRequest)(nil),
		(*ReplayOp_MakeCallable)(nil),
		(*ReplayOp_RunCallable)(nil),
		(*ReplayOp_ReleaseCallable)(nil),
		(*ReplayOp_NewReplaySession)(nil),
		(*ReplayOp_CreateSessionResponse)(nil),
		(*ReplayOp_ExtendSessionResponse)(nil),
		(*ReplayOp_PartialRunSetupResponse)(nil),
		(*ReplayOp_RunStepResponse)(nil),
		(*ReplayOp_CloseSessionResponse)(nil),
		(*ReplayOp_ListDevicesResponse)(nil),
		(*ReplayOp_ResetRequestResponse)(nil),
		(*ReplayOp_MakeCallableResponse)(nil),
		(*ReplayOp_RunCallableResponse)(nil),
		(*ReplayOp_ReleaseCallableResponse)(nil),
	}
}

func _ReplayOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*ReplayOp)
	// op
	switch x := m.Op.(type) {
	case *ReplayOp_CreateSession:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CreateSession); err != nil {
			return err
		}
	case *ReplayOp_ExtendSession:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ExtendSession); err != nil {
			return err
		}
	case *ReplayOp_PartialRunSetup:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PartialRunSetup); err != nil {
			return err
		}
	case *ReplayOp_RunStep:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RunStep); err != nil {
			return err
		}
	case *ReplayOp_CloseSession:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CloseSession); err != nil {
			return err
		}
	case *ReplayOp_ListDevices:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ListDevices); err != nil {
			return err
		}
	case *ReplayOp_ResetRequest:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ResetRequest); err != nil {
			return err
		}
	case *ReplayOp_MakeCallable:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MakeCallable); err != nil {
			return err
		}
	case *ReplayOp_RunCallable:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RunCallable); err != nil {
			return err
		}
	case *ReplayOp_ReleaseCallable:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ReleaseCallable); err != nil {
			return err
		}
	case *ReplayOp_NewReplaySession:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NewReplaySession); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ReplayOp.Op has unexpected type %T", x)
	}
	// response
	switch x := m.Response.(type) {
	case *ReplayOp_CreateSessionResponse:
		_ = b.EncodeVarint(21<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CreateSessionResponse); err != nil {
			return err
		}
	case *ReplayOp_ExtendSessionResponse:
		_ = b.EncodeVarint(22<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ExtendSessionResponse); err != nil {
			return err
		}
	case *ReplayOp_PartialRunSetupResponse:
		_ = b.EncodeVarint(23<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PartialRunSetupResponse); err != nil {
			return err
		}
	case *ReplayOp_RunStepResponse:
		_ = b.EncodeVarint(24<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RunStepResponse); err != nil {
			return err
		}
	case *ReplayOp_CloseSessionResponse:
		_ = b.EncodeVarint(25<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CloseSessionResponse); err != nil {
			return err
		}
	case *ReplayOp_ListDevicesResponse:
		_ = b.EncodeVarint(26<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ListDevicesResponse); err != nil {
			return err
		}
	case *ReplayOp_ResetRequestResponse:
		_ = b.EncodeVarint(27<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ResetRequestResponse); err != nil {
			return err
		}
	case *ReplayOp_MakeCallableResponse:
		_ = b.EncodeVarint(28<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.MakeCallableResponse); err != nil {
			return err
		}
	case *ReplayOp_RunCallableResponse:
		_ = b.EncodeVarint(29<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RunCallableResponse); err != nil {
			return err
		}
	case *ReplayOp_ReleaseCallableResponse:
		_ = b.EncodeVarint(30<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ReleaseCallableResponse); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("ReplayOp.Response has unexpected type %T", x)
	}
	return nil
}

func _ReplayOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*ReplayOp)
	switch tag {
	case 1: // op.create_session
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CreateSessionRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_CreateSession{msg}
		return true, err
	case 2: // op.extend_session
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ExtendSessionRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_ExtendSession{msg}
		return true, err
	case 3: // op.partial_run_setup
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(PartialRunSetupRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_PartialRunSetup{msg}
		return true, err
	case 4: // op.run_step
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RunStepRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_RunStep{msg}
		return true, err
	case 5: // op.close_session
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CloseSessionRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_CloseSession{msg}
		return true, err
	case 6: // op.list_devices
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ListDevicesRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_ListDevices{msg}
		return true, err
	case 7: // op.reset_request
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResetRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_ResetRequest{msg}
		return true, err
	case 8: // op.make_callable
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MakeCallableRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_MakeCallable{msg}
		return true, err
	case 9: // op.run_callable
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RunCallableRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_RunCallable{msg}
		return true, err
	case 10: // op.release_callable
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ReleaseCallableRequest)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_ReleaseCallable{msg}
		return true, err
	case 11: // op.new_replay_session
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NewReplaySession)
		err := b.DecodeMessage(msg)
		m.Op = &ReplayOp_NewReplaySession{msg}
		return true, err
	case 21: // response.create_session_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CreateSessionResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_CreateSessionResponse{msg}
		return true, err
	case 22: // response.extend_session_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ExtendSessionResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_ExtendSessionResponse{msg}
		return true, err
	case 23: // response.partial_run_setup_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(PartialRunSetupResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_PartialRunSetupResponse{msg}
		return true, err
	case 24: // response.run_step_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RunStepResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_RunStepResponse{msg}
		return true, err
	case 25: // response.close_session_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CloseSessionResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_CloseSessionResponse{msg}
		return true, err
	case 26: // response.list_devices_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ListDevicesResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_ListDevicesResponse{msg}
		return true, err
	case 27: // response.reset_request_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ResetResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_ResetRequestResponse{msg}
		return true, err
	case 28: // response.make_callable_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(MakeCallableResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_MakeCallableResponse{msg}
		return true, err
	case 29: // response.run_callable_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RunCallableResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_RunCallableResponse{msg}
		return true, err
	case 30: // response.release_callable_response
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(ReleaseCallableResponse)
		err := b.DecodeMessage(msg)
		m.Response = &ReplayOp_ReleaseCallableResponse{msg}
		return true, err
	default:
		return false, nil
	}
}

func _ReplayOp_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*ReplayOp)
	// op
	switch x := m.Op.(type) {
	case *ReplayOp_CreateSession:
		s := proto.Size(x.CreateSession)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_ExtendSession:
		s := proto.Size(x.ExtendSession)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_PartialRunSetup:
		s := proto.Size(x.PartialRunSetup)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_RunStep:
		s := proto.Size(x.RunStep)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_CloseSession:
		s := proto.Size(x.CloseSession)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_ListDevices:
		s := proto.Size(x.ListDevices)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_ResetRequest:
		s := proto.Size(x.ResetRequest)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_MakeCallable:
		s := proto.Size(x.MakeCallable)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_RunCallable:
		s := proto.Size(x.RunCallable)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_ReleaseCallable:
		s := proto.Size(x.ReleaseCallable)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_NewReplaySession:
		s := proto.Size(x.NewReplaySession)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	// response
	switch x := m.Response.(type) {
	case *ReplayOp_CreateSessionResponse:
		s := proto.Size(x.CreateSessionResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_ExtendSessionResponse:
		s := proto.Size(x.ExtendSessionResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_PartialRunSetupResponse:
		s := proto.Size(x.PartialRunSetupResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_RunStepResponse:
		s := proto.Size(x.RunStepResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_CloseSessionResponse:
		s := proto.Size(x.CloseSessionResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_ListDevicesResponse:
		s := proto.Size(x.ListDevicesResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_ResetRequestResponse:
		s := proto.Size(x.ResetRequestResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_MakeCallableResponse:
		s := proto.Size(x.MakeCallableResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_RunCallableResponse:
		s := proto.Size(x.RunCallableResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *ReplayOp_ReleaseCallableResponse:
		s := proto.Size(x.ReleaseCallableResponse)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

func init() {
	proto.RegisterType((*NewReplaySession)(nil), "tensorflow.NewReplaySession")
	proto.RegisterType((*ReplayOp)(nil), "tensorflow.ReplayOp")
}

func init() { proto.RegisterFile("replay_log.proto", fileDescriptor_90d5038285884e03) }

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

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

func (m *ReplayOp) 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 *ReplayOp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Op != nil {
		nn2, err2 := m.Op.MarshalTo(dAtA[i:])
		if err2 != nil {
			return 0, err2
		}
		i += nn2
	}
	if m.Response != nil {
		nn3, err3 := m.Response.MarshalTo(dAtA[i:])
		if err3 != nil {
			return 0, err3
		}
		i += nn3
	}
	if m.StartTimeUs != 0 {
		dAtA[i] = 0xf9
		i++
		dAtA[i] = 0x1
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.StartTimeUs))))
		i += 8
	}
	if m.EndTimeUs != 0 {
		dAtA[i] = 0x81
		i++
		dAtA[i] = 0x2
		i++
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.EndTimeUs))))
		i += 8
	}
	return i, nil
}

func (m *ReplayOp_CreateSession) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.CreateSession != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.CreateSession.Size()))
		n4, err4 := m.CreateSession.MarshalTo(dAtA[i:])
		if err4 != nil {
			return 0, err4
		}
		i += n4
	}
	return i, nil
}
func (m *ReplayOp_ExtendSession) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ExtendSession != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.ExtendSession.Size()))
		n5, err5 := m.ExtendSession.MarshalTo(dAtA[i:])
		if err5 != nil {
			return 0, err5
		}
		i += n5
	}
	return i, nil
}
func (m *ReplayOp_PartialRunSetup) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.PartialRunSetup != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.PartialRunSetup.Size()))
		n6, err6 := m.PartialRunSetup.MarshalTo(dAtA[i:])
		if err6 != nil {
			return 0, err6
		}
		i += n6
	}
	return i, nil
}
func (m *ReplayOp_RunStep) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RunStep != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.RunStep.Size()))
		n7, err7 := m.RunStep.MarshalTo(dAtA[i:])
		if err7 != nil {
			return 0, err7
		}
		i += n7
	}
	return i, nil
}
func (m *ReplayOp_CloseSession) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.CloseSession != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.CloseSession.Size()))
		n8, err8 := m.CloseSession.MarshalTo(dAtA[i:])
		if err8 != nil {
			return 0, err8
		}
		i += n8
	}
	return i, nil
}
func (m *ReplayOp_ListDevices) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ListDevices != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.ListDevices.Size()))
		n9, err9 := m.ListDevices.MarshalTo(dAtA[i:])
		if err9 != nil {
			return 0, err9
		}
		i += n9
	}
	return i, nil
}
func (m *ReplayOp_ResetRequest) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ResetRequest != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.ResetRequest.Size()))
		n10, err10 := m.ResetRequest.MarshalTo(dAtA[i:])
		if err10 != nil {
			return 0, err10
		}
		i += n10
	}
	return i, nil
}
func (m *ReplayOp_MakeCallable) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.MakeCallable != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.MakeCallable.Size()))
		n11, err11 := m.MakeCallable.MarshalTo(dAtA[i:])
		if err11 != nil {
			return 0, err11
		}
		i += n11
	}
	return i, nil
}
func (m *ReplayOp_RunCallable) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RunCallable != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.RunCallable.Size()))
		n12, err12 := m.RunCallable.MarshalTo(dAtA[i:])
		if err12 != nil {
			return 0, err12
		}
		i += n12
	}
	return i, nil
}
func (m *ReplayOp_ReleaseCallable) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ReleaseCallable != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.ReleaseCallable.Size()))
		n13, err13 := m.ReleaseCallable.MarshalTo(dAtA[i:])
		if err13 != nil {
			return 0, err13
		}
		i += n13
	}
	return i, nil
}
func (m *ReplayOp_NewReplaySession) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.NewReplaySession != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.NewReplaySession.Size()))
		n14, err14 := m.NewReplaySession.MarshalTo(dAtA[i:])
		if err14 != nil {
			return 0, err14
		}
		i += n14
	}
	return i, nil
}
func (m *ReplayOp_CreateSessionResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.CreateSessionResponse != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.CreateSessionResponse.Size()))
		n15, err15 := m.CreateSessionResponse.MarshalTo(dAtA[i:])
		if err15 != nil {
			return 0, err15
		}
		i += n15
	}
	return i, nil
}
func (m *ReplayOp_ExtendSessionResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ExtendSessionResponse != nil {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.ExtendSessionResponse.Size()))
		n16, err16 := m.ExtendSessionResponse.MarshalTo(dAtA[i:])
		if err16 != nil {
			return 0, err16
		}
		i += n16
	}
	return i, nil
}
func (m *ReplayOp_PartialRunSetupResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.PartialRunSetupResponse != nil {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.PartialRunSetupResponse.Size()))
		n17, err17 := m.PartialRunSetupResponse.MarshalTo(dAtA[i:])
		if err17 != nil {
			return 0, err17
		}
		i += n17
	}
	return i, nil
}
func (m *ReplayOp_RunStepResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RunStepResponse != nil {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.RunStepResponse.Size()))
		n18, err18 := m.RunStepResponse.MarshalTo(dAtA[i:])
		if err18 != nil {
			return 0, err18
		}
		i += n18
	}
	return i, nil
}
func (m *ReplayOp_CloseSessionResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.CloseSessionResponse != nil {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.CloseSessionResponse.Size()))
		n19, err19 := m.CloseSessionResponse.MarshalTo(dAtA[i:])
		if err19 != nil {
			return 0, err19
		}
		i += n19
	}
	return i, nil
}
func (m *ReplayOp_ListDevicesResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ListDevicesResponse != nil {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.ListDevicesResponse.Size()))
		n20, err20 := m.ListDevicesResponse.MarshalTo(dAtA[i:])
		if err20 != nil {
			return 0, err20
		}
		i += n20
	}
	return i, nil
}
func (m *ReplayOp_ResetRequestResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ResetRequestResponse != nil {
		dAtA[i] = 0xda
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.ResetRequestResponse.Size()))
		n21, err21 := m.ResetRequestResponse.MarshalTo(dAtA[i:])
		if err21 != nil {
			return 0, err21
		}
		i += n21
	}
	return i, nil
}
func (m *ReplayOp_MakeCallableResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.MakeCallableResponse != nil {
		dAtA[i] = 0xe2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.MakeCallableResponse.Size()))
		n22, err22 := m.MakeCallableResponse.MarshalTo(dAtA[i:])
		if err22 != nil {
			return 0, err22
		}
		i += n22
	}
	return i, nil
}
func (m *ReplayOp_RunCallableResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RunCallableResponse != nil {
		dAtA[i] = 0xea
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.RunCallableResponse.Size()))
		n23, err23 := m.RunCallableResponse.MarshalTo(dAtA[i:])
		if err23 != nil {
			return 0, err23
		}
		i += n23
	}
	return i, nil
}
func (m *ReplayOp_ReleaseCallableResponse) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ReleaseCallableResponse != nil {
		dAtA[i] = 0xf2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintReplayLog(dAtA, i, uint64(m.ReleaseCallableResponse.Size()))
		n24, err24 := m.ReleaseCallableResponse.MarshalTo(dAtA[i:])
		if err24 != nil {
			return 0, err24
		}
		i += n24
	}
	return i, nil
}
func encodeVarintReplayLog(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 *NewReplaySession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Devices != nil {
		l = m.Devices.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	l = len(m.SessionHandle)
	if l > 0 {
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}

func (m *ReplayOp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Op != nil {
		n += m.Op.Size()
	}
	if m.Response != nil {
		n += m.Response.Size()
	}
	if m.StartTimeUs != 0 {
		n += 10
	}
	if m.EndTimeUs != 0 {
		n += 10
	}
	return n
}

func (m *ReplayOp_CreateSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateSession != nil {
		l = m.CreateSession.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_ExtendSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExtendSession != nil {
		l = m.ExtendSession.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_PartialRunSetup) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PartialRunSetup != nil {
		l = m.PartialRunSetup.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_RunStep) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RunStep != nil {
		l = m.RunStep.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_CloseSession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CloseSession != nil {
		l = m.CloseSession.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_ListDevices) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ListDevices != nil {
		l = m.ListDevices.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_ResetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResetRequest != nil {
		l = m.ResetRequest.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_MakeCallable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MakeCallable != nil {
		l = m.MakeCallable.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_RunCallable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RunCallable != nil {
		l = m.RunCallable.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_ReleaseCallable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReleaseCallable != nil {
		l = m.ReleaseCallable.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_NewReplaySession) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NewReplaySession != nil {
		l = m.NewReplaySession.Size()
		n += 1 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_CreateSessionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CreateSessionResponse != nil {
		l = m.CreateSessionResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_ExtendSessionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ExtendSessionResponse != nil {
		l = m.ExtendSessionResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_PartialRunSetupResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PartialRunSetupResponse != nil {
		l = m.PartialRunSetupResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_RunStepResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RunStepResponse != nil {
		l = m.RunStepResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_CloseSessionResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CloseSessionResponse != nil {
		l = m.CloseSessionResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_ListDevicesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ListDevicesResponse != nil {
		l = m.ListDevicesResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_ResetRequestResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResetRequestResponse != nil {
		l = m.ResetRequestResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_MakeCallableResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MakeCallableResponse != nil {
		l = m.MakeCallableResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_RunCallableResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RunCallableResponse != nil {
		l = m.RunCallableResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}
func (m *ReplayOp_ReleaseCallableResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReleaseCallableResponse != nil {
		l = m.ReleaseCallableResponse.Size()
		n += 2 + l + sovReplayLog(uint64(l))
	}
	return n
}

func sovReplayLog(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozReplayLog(x uint64) (n int) {
	return sovReplayLog(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *NewReplaySession) 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 ErrIntOverflowReplayLog
			}
			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: NewReplaySession: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NewReplaySession: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Devices == nil {
				m.Devices = &ListDevicesResponse{}
			}
			if err := m.Devices.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 ErrIntOverflowReplayLog
				}
				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 ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SessionHandle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipReplayLog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthReplayLog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthReplayLog
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplayOp) 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 ErrIntOverflowReplayLog
			}
			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: ReplayOp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplayOp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateSession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CreateSessionRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_CreateSession{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtendSession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ExtendSessionRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_ExtendSession{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartialRunSetup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &PartialRunSetupRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_PartialRunSetup{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RunStep", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RunStepRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_RunStep{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloseSession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CloseSessionRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_CloseSession{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListDevices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ListDevicesRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_ListDevices{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResetRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ResetRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_ResetRequest{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MakeCallable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MakeCallableRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_MakeCallable{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RunCallable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RunCallableRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_RunCallable{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReleaseCallable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReleaseCallableRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_ReleaseCallable{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewReplaySession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &NewReplaySession{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Op = &ReplayOp_NewReplaySession{v}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateSessionResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CreateSessionResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_CreateSessionResponse{v}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExtendSessionResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ExtendSessionResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_ExtendSessionResponse{v}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartialRunSetupResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &PartialRunSetupResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_PartialRunSetupResponse{v}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RunStepResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RunStepResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_RunStepResponse{v}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloseSessionResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CloseSessionResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_CloseSessionResponse{v}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListDevicesResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ListDevicesResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_ListDevicesResponse{v}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResetRequestResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ResetResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_ResetRequestResponse{v}
			iNdEx = postIndex
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MakeCallableResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &MakeCallableResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_MakeCallableResponse{v}
			iNdEx = postIndex
		case 29:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RunCallableResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &RunCallableResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_RunCallableResponse{v}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReleaseCallableResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowReplayLog
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthReplayLog
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthReplayLog
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &ReleaseCallableResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Response = &ReplayOp_ReleaseCallableResponse{v}
			iNdEx = postIndex
		case 31:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTimeUs", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.StartTimeUs = float64(math.Float64frombits(v))
		case 32:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndTimeUs", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.EndTimeUs = float64(math.Float64frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipReplayLog(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthReplayLog
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthReplayLog
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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