github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/kv/kvnemesis/operations.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: kv/kvnemesis/operations.proto

package kvnemesis

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import errorspb "github.com/cockroachdb/errors/errorspb"
import roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"
import hlc "github.com/cockroachdb/cockroach/pkg/util/hlc"

import io "io"

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

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

type ClosureTxnType int32

const (
	ClosureTxnType_Commit   ClosureTxnType = 0
	ClosureTxnType_Rollback ClosureTxnType = 1
)

var ClosureTxnType_name = map[int32]string{
	0: "Commit",
	1: "Rollback",
}
var ClosureTxnType_value = map[string]int32{
	"Commit":   0,
	"Rollback": 1,
}

func (x ClosureTxnType) String() string {
	return proto.EnumName(ClosureTxnType_name, int32(x))
}
func (ClosureTxnType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_operations_a296c8d9789a3e0e, []int{0}
}

type ResultType int32

const (
	ResultType_Unknown ResultType = 0
	ResultType_NoError ResultType = 1
	ResultType_Error   ResultType = 2
	ResultType_Value   ResultType = 3
)

var ResultType_name = map[int32]string{
	0: "Unknown",
	1: "NoError",
	2: "Error",
	3: "Value",
}
var ResultType_value = map[string]int32{
	"Unknown": 0,
	"NoError": 1,
	"Error":   2,
	"Value":   3,
}

func (x ResultType) String() string {
	return proto.EnumName(ResultType_name, int32(x))
}
func (ResultType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_operations_a296c8d9789a3e0e, []int{1}
}

type BatchOperation struct {
	Ops    []Operation `protobuf:"bytes,1,rep,name=ops,proto3" json:"ops"`
	Result Result      `protobuf:"bytes,2,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_BatchOperation proto.InternalMessageInfo

type ClosureTxnOperation struct {
	TxnID         string               `protobuf:"bytes,1,opt,name=txn_id,json=txnId,proto3" json:"txn_id,omitempty"`
	Ops           []Operation          `protobuf:"bytes,2,rep,name=ops,proto3" json:"ops"`
	CommitInBatch *BatchOperation      `protobuf:"bytes,3,opt,name=commit_in_batch,json=commitInBatch,proto3" json:"commit_in_batch,omitempty"`
	Type          ClosureTxnType       `protobuf:"varint,4,opt,name=type,proto3,enum=cockroach.kv.kvnemesis.ClosureTxnType" json:"type,omitempty"`
	Result        Result               `protobuf:"bytes,5,opt,name=result,proto3" json:"result"`
	Txn           *roachpb.Transaction `protobuf:"bytes,6,opt,name=txn,proto3" json:"txn,omitempty"`
}

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

var xxx_messageInfo_ClosureTxnOperation proto.InternalMessageInfo

type GetOperation struct {
	Key    []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Result Result `protobuf:"bytes,2,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_GetOperation proto.InternalMessageInfo

type PutOperation struct {
	Key    []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value  []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	Result Result `protobuf:"bytes,3,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_PutOperation proto.InternalMessageInfo

type SplitOperation struct {
	Key    []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Result Result `protobuf:"bytes,2,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_SplitOperation proto.InternalMessageInfo

type MergeOperation struct {
	Key    []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Result Result `protobuf:"bytes,2,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_MergeOperation proto.InternalMessageInfo

type ChangeReplicasOperation struct {
	Key     []byte                      `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Changes []roachpb.ReplicationChange `protobuf:"bytes,2,rep,name=changes,proto3" json:"changes"`
	Result  Result                      `protobuf:"bytes,3,opt,name=result,proto3" json:"result"`
}

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

var xxx_messageInfo_ChangeReplicasOperation proto.InternalMessageInfo

type Operation struct {
	Batch *BatchOperation `protobuf:"bytes,1,opt,name=batch,proto3" json:"batch,omitempty"`
	// TODO(dan): The original prototype of kvnemesis had separate operations for
	// {Begin,Use,Commit,Rollback}Txn, which helped generate more interesting
	// concurrency traffic. This had some issues with deadlock in the txn wait
	// queue, but it seems like it should be possible to bring it back somehow.
	ClosureTxn     *ClosureTxnOperation     `protobuf:"bytes,2,opt,name=closure_txn,json=closureTxn,proto3" json:"closure_txn,omitempty"`
	Get            *GetOperation            `protobuf:"bytes,7,opt,name=get,proto3" json:"get,omitempty"`
	Put            *PutOperation            `protobuf:"bytes,8,opt,name=put,proto3" json:"put,omitempty"`
	Split          *SplitOperation          `protobuf:"bytes,9,opt,name=split,proto3" json:"split,omitempty"`
	Merge          *MergeOperation          `protobuf:"bytes,10,opt,name=merge,proto3" json:"merge,omitempty"`
	ChangeReplicas *ChangeReplicasOperation `protobuf:"bytes,11,opt,name=change_replicas,json=changeReplicas,proto3" json:"change_replicas,omitempty"`
}

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

var xxx_messageInfo_Operation proto.InternalMessageInfo

type Result struct {
	Type ResultType             `protobuf:"varint,1,opt,name=type,proto3,enum=cockroach.kv.kvnemesis.ResultType" json:"type,omitempty"`
	Err  *errorspb.EncodedError `protobuf:"bytes,2,opt,name=err,proto3" json:"err,omitempty"`
	// Only set if Type is ResultType_Value. The RawBytes of a roachpb.Value.
	Value []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
}

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

var xxx_messageInfo_Result proto.InternalMessageInfo

type Step struct {
	Op     Operation     `protobuf:"bytes,1,opt,name=op,proto3" json:"op"`
	Before hlc.Timestamp `protobuf:"bytes,2,opt,name=before,proto3" json:"before"`
	After  hlc.Timestamp `protobuf:"bytes,3,opt,name=after,proto3" json:"after"`
	DBID   int32         `protobuf:"varint,4,opt,name=db_id,json=dbId,proto3" json:"db_id,omitempty"`
	// Trace will contain the recording of the Step's execution. Used to print it
	// out when the test fails.
	Trace string `protobuf:"bytes,5,opt,name=trace,proto3" json:"trace,omitempty"`
}

func (m *Step) Reset()      { *m = Step{} }
func (*Step) ProtoMessage() {}
func (*Step) Descriptor() ([]byte, []int) {
	return fileDescriptor_operations_a296c8d9789a3e0e, []int{9}
}
func (m *Step) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Step) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalTo(b)
	if err != nil {
		return nil, err
	}
	return b[:n], nil
}
func (dst *Step) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Step.Merge(dst, src)
}
func (m *Step) XXX_Size() int {
	return m.Size()
}
func (m *Step) XXX_DiscardUnknown() {
	xxx_messageInfo_Step.DiscardUnknown(m)
}

var xxx_messageInfo_Step proto.InternalMessageInfo

func init() {
	proto.RegisterType((*BatchOperation)(nil), "cockroach.kv.kvnemesis.BatchOperation")
	proto.RegisterType((*ClosureTxnOperation)(nil), "cockroach.kv.kvnemesis.ClosureTxnOperation")
	proto.RegisterType((*GetOperation)(nil), "cockroach.kv.kvnemesis.GetOperation")
	proto.RegisterType((*PutOperation)(nil), "cockroach.kv.kvnemesis.PutOperation")
	proto.RegisterType((*SplitOperation)(nil), "cockroach.kv.kvnemesis.SplitOperation")
	proto.RegisterType((*MergeOperation)(nil), "cockroach.kv.kvnemesis.MergeOperation")
	proto.RegisterType((*ChangeReplicasOperation)(nil), "cockroach.kv.kvnemesis.ChangeReplicasOperation")
	proto.RegisterType((*Operation)(nil), "cockroach.kv.kvnemesis.Operation")
	proto.RegisterType((*Result)(nil), "cockroach.kv.kvnemesis.Result")
	proto.RegisterType((*Step)(nil), "cockroach.kv.kvnemesis.Step")
	proto.RegisterEnum("cockroach.kv.kvnemesis.ClosureTxnType", ClosureTxnType_name, ClosureTxnType_value)
	proto.RegisterEnum("cockroach.kv.kvnemesis.ResultType", ResultType_name, ResultType_value)
}
func (m *BatchOperation) 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 *BatchOperation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Ops) > 0 {
		for _, msg := range m.Ops {
			dAtA[i] = 0xa
			i++
			i = encodeVarintOperations(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Result.Size()))
	n1, err := m.Result.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	return i, nil
}

func (m *ClosureTxnOperation) 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 *ClosureTxnOperation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.TxnID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.TxnID)))
		i += copy(dAtA[i:], m.TxnID)
	}
	if len(m.Ops) > 0 {
		for _, msg := range m.Ops {
			dAtA[i] = 0x12
			i++
			i = encodeVarintOperations(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.CommitInBatch != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.CommitInBatch.Size()))
		n2, err := m.CommitInBatch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Type != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Type))
	}
	dAtA[i] = 0x2a
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Result.Size()))
	n3, err := m.Result.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	if m.Txn != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Txn.Size()))
		n4, err := m.Txn.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

func (m *GetOperation) 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 *GetOperation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Result.Size()))
	n5, err := m.Result.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	return i, nil
}

func (m *PutOperation) 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 *PutOperation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.Value) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Result.Size()))
	n6, err := m.Result.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	return i, nil
}

func (m *SplitOperation) 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 *SplitOperation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Result.Size()))
	n7, err := m.Result.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	return i, nil
}

func (m *MergeOperation) 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 *MergeOperation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Result.Size()))
	n8, err := m.Result.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n8
	return i, nil
}

func (m *ChangeReplicasOperation) 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 *ChangeReplicasOperation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if len(m.Changes) > 0 {
		for _, msg := range m.Changes {
			dAtA[i] = 0x12
			i++
			i = encodeVarintOperations(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Result.Size()))
	n9, err := m.Result.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n9
	return i, nil
}

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

func (m *Operation) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Batch != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Batch.Size()))
		n10, err := m.Batch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.ClosureTxn != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.ClosureTxn.Size()))
		n11, err := m.ClosureTxn.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.Get != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Get.Size()))
		n12, err := m.Get.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.Put != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Put.Size()))
		n13, err := m.Put.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if m.Split != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Split.Size()))
		n14, err := m.Split.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if m.Merge != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Merge.Size()))
		n15, err := m.Merge.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	if m.ChangeReplicas != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.ChangeReplicas.Size()))
		n16, err := m.ChangeReplicas.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}

func (m *Result) 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 *Result) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Type))
	}
	if m.Err != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.Err.Size()))
		n17, err := m.Err.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if len(m.Value) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	return i, nil
}

func (m *Step) 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 *Step) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Op.Size()))
	n18, err := m.Op.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n18
	dAtA[i] = 0x12
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.Before.Size()))
	n19, err := m.Before.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n19
	dAtA[i] = 0x1a
	i++
	i = encodeVarintOperations(dAtA, i, uint64(m.After.Size()))
	n20, err := m.After.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n20
	if m.DBID != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintOperations(dAtA, i, uint64(m.DBID))
	}
	if len(m.Trace) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintOperations(dAtA, i, uint64(len(m.Trace)))
		i += copy(dAtA[i:], m.Trace)
	}
	return i, nil
}

func encodeVarintOperations(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 *BatchOperation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Ops) > 0 {
		for _, e := range m.Ops {
			l = e.Size()
			n += 1 + l + sovOperations(uint64(l))
		}
	}
	l = m.Result.Size()
	n += 1 + l + sovOperations(uint64(l))
	return n
}

func (m *ClosureTxnOperation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TxnID)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	if len(m.Ops) > 0 {
		for _, e := range m.Ops {
			l = e.Size()
			n += 1 + l + sovOperations(uint64(l))
		}
	}
	if m.CommitInBatch != nil {
		l = m.CommitInBatch.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovOperations(uint64(m.Type))
	}
	l = m.Result.Size()
	n += 1 + l + sovOperations(uint64(l))
	if m.Txn != nil {
		l = m.Txn.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

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

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

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

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

func (m *ChangeReplicasOperation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	if len(m.Changes) > 0 {
		for _, e := range m.Changes {
			l = e.Size()
			n += 1 + l + sovOperations(uint64(l))
		}
	}
	l = m.Result.Size()
	n += 1 + l + sovOperations(uint64(l))
	return n
}

func (m *Operation) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Batch != nil {
		l = m.Batch.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.ClosureTxn != nil {
		l = m.ClosureTxn.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.Get != nil {
		l = m.Get.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.Put != nil {
		l = m.Put.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.Split != nil {
		l = m.Split.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.Merge != nil {
		l = m.Merge.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	if m.ChangeReplicas != nil {
		l = m.ChangeReplicas.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *Result) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovOperations(uint64(m.Type))
	}
	if m.Err != nil {
		l = m.Err.Size()
		n += 1 + l + sovOperations(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func (m *Step) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Op.Size()
	n += 1 + l + sovOperations(uint64(l))
	l = m.Before.Size()
	n += 1 + l + sovOperations(uint64(l))
	l = m.After.Size()
	n += 1 + l + sovOperations(uint64(l))
	if m.DBID != 0 {
		n += 1 + sovOperations(uint64(m.DBID))
	}
	l = len(m.Trace)
	if l > 0 {
		n += 1 + l + sovOperations(uint64(l))
	}
	return n
}

func sovOperations(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozOperations(x uint64) (n int) {
	return sovOperations(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Operation) GetValue() interface{} {
	if this.Batch != nil {
		return this.Batch
	}
	if this.ClosureTxn != nil {
		return this.ClosureTxn
	}
	if this.Get != nil {
		return this.Get
	}
	if this.Put != nil {
		return this.Put
	}
	if this.Split != nil {
		return this.Split
	}
	if this.Merge != nil {
		return this.Merge
	}
	if this.ChangeReplicas != nil {
		return this.ChangeReplicas
	}
	return nil
}

func (this *Operation) SetValue(value interface{}) bool {
	switch vt := value.(type) {
	case *BatchOperation:
		this.Batch = vt
	case *ClosureTxnOperation:
		this.ClosureTxn = vt
	case *GetOperation:
		this.Get = vt
	case *PutOperation:
		this.Put = vt
	case *SplitOperation:
		this.Split = vt
	case *MergeOperation:
		this.Merge = vt
	case *ChangeReplicasOperation:
		this.ChangeReplicas = vt
	default:
		return false
	}
	return true
}
func (m *BatchOperation) 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 ErrIntOverflowOperations
			}
			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: BatchOperation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchOperation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ops", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ops = append(m.Ops, Operation{})
			if err := m.Ops[len(m.Ops)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClosureTxnOperation) 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 ErrIntOverflowOperations
			}
			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: ClosureTxnOperation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClosureTxnOperation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxnID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ops", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ops = append(m.Ops, Operation{})
			if err := m.Ops[len(m.Ops)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommitInBatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CommitInBatch == nil {
				m.CommitInBatch = &BatchOperation{}
			}
			if err := m.CommitInBatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (ClosureTxnType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Txn == nil {
				m.Txn = &roachpb.Transaction{}
			}
			if err := m.Txn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Operation) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowOperations
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Operation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Operation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Batch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Batch == nil {
				m.Batch = &BatchOperation{}
			}
			if err := m.Batch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClosureTxn", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ClosureTxn == nil {
				m.ClosureTxn = &ClosureTxnOperation{}
			}
			if err := m.ClosureTxn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Get", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Get == nil {
				m.Get = &GetOperation{}
			}
			if err := m.Get.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Put", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Put == nil {
				m.Put = &PutOperation{}
			}
			if err := m.Put.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Split", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Split == nil {
				m.Split = &SplitOperation{}
			}
			if err := m.Split.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Merge == nil {
				m.Merge = &MergeOperation{}
			}
			if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangeReplicas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangeReplicas == nil {
				m.ChangeReplicas = &ChangeReplicasOperation{}
			}
			if err := m.ChangeReplicas.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Result) 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 ErrIntOverflowOperations
			}
			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: Result: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Result: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (ResultType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Err == nil {
				m.Err = &errorspb.EncodedError{}
			}
			if err := m.Err.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Step) 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 ErrIntOverflowOperations
			}
			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: Step: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Step: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Op.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Before", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Before.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field After", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthOperations
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.After.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DBID", wireType)
			}
			m.DBID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DBID |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Trace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowOperations
				}
				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 ErrInvalidLengthOperations
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Trace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipOperations(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthOperations
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

func init() {
	proto.RegisterFile("kv/kvnemesis/operations.proto", fileDescriptor_operations_a296c8d9789a3e0e)
}

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