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

package tikvpb

import (
	"fmt"
	"io"
	"math"

	proto "github.com/golang/protobuf/proto"

	_ "github.com/gogo/protobuf/gogoproto"

	coprocessor "github.com/pingcap/kvproto/pkg/coprocessor"

	kvrpcpb "github.com/pingcap/kvproto/pkg/kvrpcpb"

	raft_serverpb "github.com/pingcap/kvproto/pkg/raft_serverpb"

	context "golang.org/x/net/context"

	grpc "google.golang.org/grpc"
)

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

type BatchCommandsRequest struct {
	Requests             []*BatchCommandsRequest_Request `protobuf:"bytes,1,rep,name=requests" json:"requests,omitempty"`
	RequestIds           []uint64                        `protobuf:"varint,2,rep,packed,name=request_ids,json=requestIds" json:"request_ids,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

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

var xxx_messageInfo_BatchCommandsRequest proto.InternalMessageInfo

func (m *BatchCommandsRequest) GetRequests() []*BatchCommandsRequest_Request {
	if m != nil {
		return m.Requests
	}
	return nil
}

func (m *BatchCommandsRequest) GetRequestIds() []uint64 {
	if m != nil {
		return m.RequestIds
	}
	return nil
}

type BatchCommandsRequest_Request struct {
	// Types that are valid to be assigned to Cmd:
	//	*BatchCommandsRequest_Request_Get
	//	*BatchCommandsRequest_Request_Scan
	//	*BatchCommandsRequest_Request_Prewrite
	//	*BatchCommandsRequest_Request_Commit
	//	*BatchCommandsRequest_Request_Import
	//	*BatchCommandsRequest_Request_Cleanup
	//	*BatchCommandsRequest_Request_BatchGet
	//	*BatchCommandsRequest_Request_BatchRollback
	//	*BatchCommandsRequest_Request_ScanLock
	//	*BatchCommandsRequest_Request_ResolveLock
	//	*BatchCommandsRequest_Request_GC
	//	*BatchCommandsRequest_Request_DeleteRange
	//	*BatchCommandsRequest_Request_RawGet
	//	*BatchCommandsRequest_Request_RawBatchGet
	//	*BatchCommandsRequest_Request_RawPut
	//	*BatchCommandsRequest_Request_RawBatchPut
	//	*BatchCommandsRequest_Request_RawDelete
	//	*BatchCommandsRequest_Request_RawBatchDelete
	//	*BatchCommandsRequest_Request_RawScan
	//	*BatchCommandsRequest_Request_RawDeleteRange
	//	*BatchCommandsRequest_Request_RawBatchScan
	//	*BatchCommandsRequest_Request_Coprocessor
	//	*BatchCommandsRequest_Request_PessimisticLock
	//	*BatchCommandsRequest_Request_PessimisticRollback
	//	*BatchCommandsRequest_Request_CheckTxnStatus
	//	*BatchCommandsRequest_Request_TxnHeartBeat
	//	*BatchCommandsRequest_Request_Empty
	Cmd                  isBatchCommandsRequest_Request_Cmd `protobuf_oneof:"cmd"`
	XXX_NoUnkeyedLiteral struct{}                           `json:"-"`
	XXX_unrecognized     []byte                             `json:"-"`
	XXX_sizecache        int32                              `json:"-"`
}

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

var xxx_messageInfo_BatchCommandsRequest_Request proto.InternalMessageInfo

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

type BatchCommandsRequest_Request_Get struct {
	Get *kvrpcpb.GetRequest `protobuf:"bytes,1,opt,name=Get,oneof"`
}
type BatchCommandsRequest_Request_Scan struct {
	Scan *kvrpcpb.ScanRequest `protobuf:"bytes,2,opt,name=Scan,oneof"`
}
type BatchCommandsRequest_Request_Prewrite struct {
	Prewrite *kvrpcpb.PrewriteRequest `protobuf:"bytes,3,opt,name=Prewrite,oneof"`
}
type BatchCommandsRequest_Request_Commit struct {
	Commit *kvrpcpb.CommitRequest `protobuf:"bytes,4,opt,name=Commit,oneof"`
}
type BatchCommandsRequest_Request_Import struct {
	Import *kvrpcpb.ImportRequest `protobuf:"bytes,5,opt,name=Import,oneof"`
}
type BatchCommandsRequest_Request_Cleanup struct {
	Cleanup *kvrpcpb.CleanupRequest `protobuf:"bytes,6,opt,name=Cleanup,oneof"`
}
type BatchCommandsRequest_Request_BatchGet struct {
	BatchGet *kvrpcpb.BatchGetRequest `protobuf:"bytes,7,opt,name=BatchGet,oneof"`
}
type BatchCommandsRequest_Request_BatchRollback struct {
	BatchRollback *kvrpcpb.BatchRollbackRequest `protobuf:"bytes,8,opt,name=BatchRollback,oneof"`
}
type BatchCommandsRequest_Request_ScanLock struct {
	ScanLock *kvrpcpb.ScanLockRequest `protobuf:"bytes,9,opt,name=ScanLock,oneof"`
}
type BatchCommandsRequest_Request_ResolveLock struct {
	ResolveLock *kvrpcpb.ResolveLockRequest `protobuf:"bytes,10,opt,name=ResolveLock,oneof"`
}
type BatchCommandsRequest_Request_GC struct {
	GC *kvrpcpb.GCRequest `protobuf:"bytes,11,opt,name=GC,oneof"`
}
type BatchCommandsRequest_Request_DeleteRange struct {
	DeleteRange *kvrpcpb.DeleteRangeRequest `protobuf:"bytes,12,opt,name=DeleteRange,oneof"`
}
type BatchCommandsRequest_Request_RawGet struct {
	RawGet *kvrpcpb.RawGetRequest `protobuf:"bytes,13,opt,name=RawGet,oneof"`
}
type BatchCommandsRequest_Request_RawBatchGet struct {
	RawBatchGet *kvrpcpb.RawBatchGetRequest `protobuf:"bytes,14,opt,name=RawBatchGet,oneof"`
}
type BatchCommandsRequest_Request_RawPut struct {
	RawPut *kvrpcpb.RawPutRequest `protobuf:"bytes,15,opt,name=RawPut,oneof"`
}
type BatchCommandsRequest_Request_RawBatchPut struct {
	RawBatchPut *kvrpcpb.RawBatchPutRequest `protobuf:"bytes,16,opt,name=RawBatchPut,oneof"`
}
type BatchCommandsRequest_Request_RawDelete struct {
	RawDelete *kvrpcpb.RawDeleteRequest `protobuf:"bytes,17,opt,name=RawDelete,oneof"`
}
type BatchCommandsRequest_Request_RawBatchDelete struct {
	RawBatchDelete *kvrpcpb.RawBatchDeleteRequest `protobuf:"bytes,18,opt,name=RawBatchDelete,oneof"`
}
type BatchCommandsRequest_Request_RawScan struct {
	RawScan *kvrpcpb.RawScanRequest `protobuf:"bytes,19,opt,name=RawScan,oneof"`
}
type BatchCommandsRequest_Request_RawDeleteRange struct {
	RawDeleteRange *kvrpcpb.RawDeleteRangeRequest `protobuf:"bytes,20,opt,name=RawDeleteRange,oneof"`
}
type BatchCommandsRequest_Request_RawBatchScan struct {
	RawBatchScan *kvrpcpb.RawBatchScanRequest `protobuf:"bytes,21,opt,name=RawBatchScan,oneof"`
}
type BatchCommandsRequest_Request_Coprocessor struct {
	Coprocessor *coprocessor.Request `protobuf:"bytes,22,opt,name=Coprocessor,oneof"`
}
type BatchCommandsRequest_Request_PessimisticLock struct {
	PessimisticLock *kvrpcpb.PessimisticLockRequest `protobuf:"bytes,23,opt,name=PessimisticLock,oneof"`
}
type BatchCommandsRequest_Request_PessimisticRollback struct {
	PessimisticRollback *kvrpcpb.PessimisticRollbackRequest `protobuf:"bytes,24,opt,name=PessimisticRollback,oneof"`
}
type BatchCommandsRequest_Request_CheckTxnStatus struct {
	CheckTxnStatus *kvrpcpb.CheckTxnStatusRequest `protobuf:"bytes,25,opt,name=CheckTxnStatus,oneof"`
}
type BatchCommandsRequest_Request_TxnHeartBeat struct {
	TxnHeartBeat *kvrpcpb.TxnHeartBeatRequest `protobuf:"bytes,26,opt,name=TxnHeartBeat,oneof"`
}
type BatchCommandsRequest_Request_Empty struct {
	Empty *BatchCommandsEmptyRequest `protobuf:"bytes,255,opt,name=Empty,oneof"`
}

func (*BatchCommandsRequest_Request_Get) isBatchCommandsRequest_Request_Cmd()                 {}
func (*BatchCommandsRequest_Request_Scan) isBatchCommandsRequest_Request_Cmd()                {}
func (*BatchCommandsRequest_Request_Prewrite) isBatchCommandsRequest_Request_Cmd()            {}
func (*BatchCommandsRequest_Request_Commit) isBatchCommandsRequest_Request_Cmd()              {}
func (*BatchCommandsRequest_Request_Import) isBatchCommandsRequest_Request_Cmd()              {}
func (*BatchCommandsRequest_Request_Cleanup) isBatchCommandsRequest_Request_Cmd()             {}
func (*BatchCommandsRequest_Request_BatchGet) isBatchCommandsRequest_Request_Cmd()            {}
func (*BatchCommandsRequest_Request_BatchRollback) isBatchCommandsRequest_Request_Cmd()       {}
func (*BatchCommandsRequest_Request_ScanLock) isBatchCommandsRequest_Request_Cmd()            {}
func (*BatchCommandsRequest_Request_ResolveLock) isBatchCommandsRequest_Request_Cmd()         {}
func (*BatchCommandsRequest_Request_GC) isBatchCommandsRequest_Request_Cmd()                  {}
func (*BatchCommandsRequest_Request_DeleteRange) isBatchCommandsRequest_Request_Cmd()         {}
func (*BatchCommandsRequest_Request_RawGet) isBatchCommandsRequest_Request_Cmd()              {}
func (*BatchCommandsRequest_Request_RawBatchGet) isBatchCommandsRequest_Request_Cmd()         {}
func (*BatchCommandsRequest_Request_RawPut) isBatchCommandsRequest_Request_Cmd()              {}
func (*BatchCommandsRequest_Request_RawBatchPut) isBatchCommandsRequest_Request_Cmd()         {}
func (*BatchCommandsRequest_Request_RawDelete) isBatchCommandsRequest_Request_Cmd()           {}
func (*BatchCommandsRequest_Request_RawBatchDelete) isBatchCommandsRequest_Request_Cmd()      {}
func (*BatchCommandsRequest_Request_RawScan) isBatchCommandsRequest_Request_Cmd()             {}
func (*BatchCommandsRequest_Request_RawDeleteRange) isBatchCommandsRequest_Request_Cmd()      {}
func (*BatchCommandsRequest_Request_RawBatchScan) isBatchCommandsRequest_Request_Cmd()        {}
func (*BatchCommandsRequest_Request_Coprocessor) isBatchCommandsRequest_Request_Cmd()         {}
func (*BatchCommandsRequest_Request_PessimisticLock) isBatchCommandsRequest_Request_Cmd()     {}
func (*BatchCommandsRequest_Request_PessimisticRollback) isBatchCommandsRequest_Request_Cmd() {}
func (*BatchCommandsRequest_Request_CheckTxnStatus) isBatchCommandsRequest_Request_Cmd()      {}
func (*BatchCommandsRequest_Request_TxnHeartBeat) isBatchCommandsRequest_Request_Cmd()        {}
func (*BatchCommandsRequest_Request_Empty) isBatchCommandsRequest_Request_Cmd()               {}

func (m *BatchCommandsRequest_Request) GetCmd() isBatchCommandsRequest_Request_Cmd {
	if m != nil {
		return m.Cmd
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetGet() *kvrpcpb.GetRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Get); ok {
		return x.Get
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetScan() *kvrpcpb.ScanRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Scan); ok {
		return x.Scan
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetPrewrite() *kvrpcpb.PrewriteRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Prewrite); ok {
		return x.Prewrite
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetCommit() *kvrpcpb.CommitRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Commit); ok {
		return x.Commit
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetImport() *kvrpcpb.ImportRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Import); ok {
		return x.Import
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetCleanup() *kvrpcpb.CleanupRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Cleanup); ok {
		return x.Cleanup
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetBatchGet() *kvrpcpb.BatchGetRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_BatchGet); ok {
		return x.BatchGet
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetBatchRollback() *kvrpcpb.BatchRollbackRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_BatchRollback); ok {
		return x.BatchRollback
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetScanLock() *kvrpcpb.ScanLockRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_ScanLock); ok {
		return x.ScanLock
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetResolveLock() *kvrpcpb.ResolveLockRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_ResolveLock); ok {
		return x.ResolveLock
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetGC() *kvrpcpb.GCRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_GC); ok {
		return x.GC
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetDeleteRange() *kvrpcpb.DeleteRangeRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_DeleteRange); ok {
		return x.DeleteRange
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawGet() *kvrpcpb.RawGetRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawGet); ok {
		return x.RawGet
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawBatchGet() *kvrpcpb.RawBatchGetRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawBatchGet); ok {
		return x.RawBatchGet
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawPut() *kvrpcpb.RawPutRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawPut); ok {
		return x.RawPut
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawBatchPut() *kvrpcpb.RawBatchPutRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawBatchPut); ok {
		return x.RawBatchPut
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawDelete() *kvrpcpb.RawDeleteRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawDelete); ok {
		return x.RawDelete
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawBatchDelete() *kvrpcpb.RawBatchDeleteRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawBatchDelete); ok {
		return x.RawBatchDelete
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawScan() *kvrpcpb.RawScanRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawScan); ok {
		return x.RawScan
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawDeleteRange() *kvrpcpb.RawDeleteRangeRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawDeleteRange); ok {
		return x.RawDeleteRange
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetRawBatchScan() *kvrpcpb.RawBatchScanRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_RawBatchScan); ok {
		return x.RawBatchScan
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetCoprocessor() *coprocessor.Request {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Coprocessor); ok {
		return x.Coprocessor
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetPessimisticLock() *kvrpcpb.PessimisticLockRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_PessimisticLock); ok {
		return x.PessimisticLock
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetPessimisticRollback() *kvrpcpb.PessimisticRollbackRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_PessimisticRollback); ok {
		return x.PessimisticRollback
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetCheckTxnStatus() *kvrpcpb.CheckTxnStatusRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_CheckTxnStatus); ok {
		return x.CheckTxnStatus
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetTxnHeartBeat() *kvrpcpb.TxnHeartBeatRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_TxnHeartBeat); ok {
		return x.TxnHeartBeat
	}
	return nil
}

func (m *BatchCommandsRequest_Request) GetEmpty() *BatchCommandsEmptyRequest {
	if x, ok := m.GetCmd().(*BatchCommandsRequest_Request_Empty); ok {
		return x.Empty
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*BatchCommandsRequest_Request) 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 _BatchCommandsRequest_Request_OneofMarshaler, _BatchCommandsRequest_Request_OneofUnmarshaler, _BatchCommandsRequest_Request_OneofSizer, []interface{}{
		(*BatchCommandsRequest_Request_Get)(nil),
		(*BatchCommandsRequest_Request_Scan)(nil),
		(*BatchCommandsRequest_Request_Prewrite)(nil),
		(*BatchCommandsRequest_Request_Commit)(nil),
		(*BatchCommandsRequest_Request_Import)(nil),
		(*BatchCommandsRequest_Request_Cleanup)(nil),
		(*BatchCommandsRequest_Request_BatchGet)(nil),
		(*BatchCommandsRequest_Request_BatchRollback)(nil),
		(*BatchCommandsRequest_Request_ScanLock)(nil),
		(*BatchCommandsRequest_Request_ResolveLock)(nil),
		(*BatchCommandsRequest_Request_GC)(nil),
		(*BatchCommandsRequest_Request_DeleteRange)(nil),
		(*BatchCommandsRequest_Request_RawGet)(nil),
		(*BatchCommandsRequest_Request_RawBatchGet)(nil),
		(*BatchCommandsRequest_Request_RawPut)(nil),
		(*BatchCommandsRequest_Request_RawBatchPut)(nil),
		(*BatchCommandsRequest_Request_RawDelete)(nil),
		(*BatchCommandsRequest_Request_RawBatchDelete)(nil),
		(*BatchCommandsRequest_Request_RawScan)(nil),
		(*BatchCommandsRequest_Request_RawDeleteRange)(nil),
		(*BatchCommandsRequest_Request_RawBatchScan)(nil),
		(*BatchCommandsRequest_Request_Coprocessor)(nil),
		(*BatchCommandsRequest_Request_PessimisticLock)(nil),
		(*BatchCommandsRequest_Request_PessimisticRollback)(nil),
		(*BatchCommandsRequest_Request_CheckTxnStatus)(nil),
		(*BatchCommandsRequest_Request_TxnHeartBeat)(nil),
		(*BatchCommandsRequest_Request_Empty)(nil),
	}
}

func _BatchCommandsRequest_Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*BatchCommandsRequest_Request)
	// cmd
	switch x := m.Cmd.(type) {
	case *BatchCommandsRequest_Request_Get:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Get); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_Scan:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Scan); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_Prewrite:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Prewrite); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_Commit:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Commit); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_Import:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Import); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_Cleanup:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Cleanup); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_BatchGet:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BatchGet); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_BatchRollback:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BatchRollback); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_ScanLock:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ScanLock); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_ResolveLock:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ResolveLock); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_GC:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GC); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_DeleteRange:
		_ = b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DeleteRange); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawGet:
		_ = b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawGet); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawBatchGet:
		_ = b.EncodeVarint(14<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawBatchGet); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawPut:
		_ = b.EncodeVarint(15<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawPut); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawBatchPut:
		_ = b.EncodeVarint(16<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawBatchPut); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawDelete:
		_ = b.EncodeVarint(17<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawDelete); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawBatchDelete:
		_ = b.EncodeVarint(18<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawBatchDelete); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawScan:
		_ = b.EncodeVarint(19<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawScan); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawDeleteRange:
		_ = b.EncodeVarint(20<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawDeleteRange); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_RawBatchScan:
		_ = b.EncodeVarint(21<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawBatchScan); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_Coprocessor:
		_ = b.EncodeVarint(22<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Coprocessor); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_PessimisticLock:
		_ = b.EncodeVarint(23<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PessimisticLock); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_PessimisticRollback:
		_ = b.EncodeVarint(24<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PessimisticRollback); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_CheckTxnStatus:
		_ = b.EncodeVarint(25<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CheckTxnStatus); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_TxnHeartBeat:
		_ = b.EncodeVarint(26<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TxnHeartBeat); err != nil {
			return err
		}
	case *BatchCommandsRequest_Request_Empty:
		_ = b.EncodeVarint(255<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Empty); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("BatchCommandsRequest_Request.Cmd has unexpected type %T", x)
	}
	return nil
}

func _BatchCommandsRequest_Request_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*BatchCommandsRequest_Request)
	switch tag {
	case 1: // cmd.Get
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.GetRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_Get{msg}
		return true, err
	case 2: // cmd.Scan
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.ScanRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_Scan{msg}
		return true, err
	case 3: // cmd.Prewrite
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.PrewriteRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_Prewrite{msg}
		return true, err
	case 4: // cmd.Commit
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.CommitRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_Commit{msg}
		return true, err
	case 5: // cmd.Import
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.ImportRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_Import{msg}
		return true, err
	case 6: // cmd.Cleanup
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.CleanupRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_Cleanup{msg}
		return true, err
	case 7: // cmd.BatchGet
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.BatchGetRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_BatchGet{msg}
		return true, err
	case 8: // cmd.BatchRollback
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.BatchRollbackRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_BatchRollback{msg}
		return true, err
	case 9: // cmd.ScanLock
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.ScanLockRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_ScanLock{msg}
		return true, err
	case 10: // cmd.ResolveLock
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.ResolveLockRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_ResolveLock{msg}
		return true, err
	case 11: // cmd.GC
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.GCRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_GC{msg}
		return true, err
	case 12: // cmd.DeleteRange
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.DeleteRangeRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_DeleteRange{msg}
		return true, err
	case 13: // cmd.RawGet
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawGetRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawGet{msg}
		return true, err
	case 14: // cmd.RawBatchGet
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawBatchGetRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawBatchGet{msg}
		return true, err
	case 15: // cmd.RawPut
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawPutRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawPut{msg}
		return true, err
	case 16: // cmd.RawBatchPut
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawBatchPutRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawBatchPut{msg}
		return true, err
	case 17: // cmd.RawDelete
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawDeleteRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawDelete{msg}
		return true, err
	case 18: // cmd.RawBatchDelete
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawBatchDeleteRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawBatchDelete{msg}
		return true, err
	case 19: // cmd.RawScan
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawScanRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawScan{msg}
		return true, err
	case 20: // cmd.RawDeleteRange
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawDeleteRangeRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawDeleteRange{msg}
		return true, err
	case 21: // cmd.RawBatchScan
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawBatchScanRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_RawBatchScan{msg}
		return true, err
	case 22: // cmd.Coprocessor
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(coprocessor.Request)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_Coprocessor{msg}
		return true, err
	case 23: // cmd.PessimisticLock
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.PessimisticLockRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_PessimisticLock{msg}
		return true, err
	case 24: // cmd.PessimisticRollback
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.PessimisticRollbackRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_PessimisticRollback{msg}
		return true, err
	case 25: // cmd.CheckTxnStatus
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.CheckTxnStatusRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_CheckTxnStatus{msg}
		return true, err
	case 26: // cmd.TxnHeartBeat
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.TxnHeartBeatRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_TxnHeartBeat{msg}
		return true, err
	case 255: // cmd.Empty
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(BatchCommandsEmptyRequest)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsRequest_Request_Empty{msg}
		return true, err
	default:
		return false, nil
	}
}

func _BatchCommandsRequest_Request_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*BatchCommandsRequest_Request)
	// cmd
	switch x := m.Cmd.(type) {
	case *BatchCommandsRequest_Request_Get:
		s := proto.Size(x.Get)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_Scan:
		s := proto.Size(x.Scan)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_Prewrite:
		s := proto.Size(x.Prewrite)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_Commit:
		s := proto.Size(x.Commit)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_Import:
		s := proto.Size(x.Import)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_Cleanup:
		s := proto.Size(x.Cleanup)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_BatchGet:
		s := proto.Size(x.BatchGet)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_BatchRollback:
		s := proto.Size(x.BatchRollback)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_ScanLock:
		s := proto.Size(x.ScanLock)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_ResolveLock:
		s := proto.Size(x.ResolveLock)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_GC:
		s := proto.Size(x.GC)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_DeleteRange:
		s := proto.Size(x.DeleteRange)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawGet:
		s := proto.Size(x.RawGet)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawBatchGet:
		s := proto.Size(x.RawBatchGet)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawPut:
		s := proto.Size(x.RawPut)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawBatchPut:
		s := proto.Size(x.RawBatchPut)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawDelete:
		s := proto.Size(x.RawDelete)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawBatchDelete:
		s := proto.Size(x.RawBatchDelete)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawScan:
		s := proto.Size(x.RawScan)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawDeleteRange:
		s := proto.Size(x.RawDeleteRange)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_RawBatchScan:
		s := proto.Size(x.RawBatchScan)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_Coprocessor:
		s := proto.Size(x.Coprocessor)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_PessimisticLock:
		s := proto.Size(x.PessimisticLock)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_PessimisticRollback:
		s := proto.Size(x.PessimisticRollback)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_CheckTxnStatus:
		s := proto.Size(x.CheckTxnStatus)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_TxnHeartBeat:
		s := proto.Size(x.TxnHeartBeat)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsRequest_Request_Empty:
		s := proto.Size(x.Empty)
		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
}

type BatchCommandsResponse struct {
	Responses  []*BatchCommandsResponse_Response `protobuf:"bytes,1,rep,name=responses" json:"responses,omitempty"`
	RequestIds []uint64                          `protobuf:"varint,2,rep,packed,name=request_ids,json=requestIds" json:"request_ids,omitempty"`
	// 280 means TiKV gRPC cpu usage is 280%.
	TransportLayerLoad   uint64   `protobuf:"varint,3,opt,name=transport_layer_load,json=transportLayerLoad,proto3" json:"transport_layer_load,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_BatchCommandsResponse proto.InternalMessageInfo

func (m *BatchCommandsResponse) GetResponses() []*BatchCommandsResponse_Response {
	if m != nil {
		return m.Responses
	}
	return nil
}

func (m *BatchCommandsResponse) GetRequestIds() []uint64 {
	if m != nil {
		return m.RequestIds
	}
	return nil
}

func (m *BatchCommandsResponse) GetTransportLayerLoad() uint64 {
	if m != nil {
		return m.TransportLayerLoad
	}
	return 0
}

type BatchCommandsResponse_Response struct {
	// Types that are valid to be assigned to Cmd:
	//	*BatchCommandsResponse_Response_Get
	//	*BatchCommandsResponse_Response_Scan
	//	*BatchCommandsResponse_Response_Prewrite
	//	*BatchCommandsResponse_Response_Commit
	//	*BatchCommandsResponse_Response_Import
	//	*BatchCommandsResponse_Response_Cleanup
	//	*BatchCommandsResponse_Response_BatchGet
	//	*BatchCommandsResponse_Response_BatchRollback
	//	*BatchCommandsResponse_Response_ScanLock
	//	*BatchCommandsResponse_Response_ResolveLock
	//	*BatchCommandsResponse_Response_GC
	//	*BatchCommandsResponse_Response_DeleteRange
	//	*BatchCommandsResponse_Response_RawGet
	//	*BatchCommandsResponse_Response_RawBatchGet
	//	*BatchCommandsResponse_Response_RawPut
	//	*BatchCommandsResponse_Response_RawBatchPut
	//	*BatchCommandsResponse_Response_RawDelete
	//	*BatchCommandsResponse_Response_RawBatchDelete
	//	*BatchCommandsResponse_Response_RawScan
	//	*BatchCommandsResponse_Response_RawDeleteRange
	//	*BatchCommandsResponse_Response_RawBatchScan
	//	*BatchCommandsResponse_Response_Coprocessor
	//	*BatchCommandsResponse_Response_PessimisticLock
	//	*BatchCommandsResponse_Response_PessimisticRollback
	//	*BatchCommandsResponse_Response_CheckTxnStatus
	//	*BatchCommandsResponse_Response_TxnHeartBeat
	//	*BatchCommandsResponse_Response_Empty
	Cmd                  isBatchCommandsResponse_Response_Cmd `protobuf_oneof:"cmd"`
	XXX_NoUnkeyedLiteral struct{}                             `json:"-"`
	XXX_unrecognized     []byte                               `json:"-"`
	XXX_sizecache        int32                                `json:"-"`
}

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

var xxx_messageInfo_BatchCommandsResponse_Response proto.InternalMessageInfo

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

type BatchCommandsResponse_Response_Get struct {
	Get *kvrpcpb.GetResponse `protobuf:"bytes,1,opt,name=Get,oneof"`
}
type BatchCommandsResponse_Response_Scan struct {
	Scan *kvrpcpb.ScanResponse `protobuf:"bytes,2,opt,name=Scan,oneof"`
}
type BatchCommandsResponse_Response_Prewrite struct {
	Prewrite *kvrpcpb.PrewriteResponse `protobuf:"bytes,3,opt,name=Prewrite,oneof"`
}
type BatchCommandsResponse_Response_Commit struct {
	Commit *kvrpcpb.CommitResponse `protobuf:"bytes,4,opt,name=Commit,oneof"`
}
type BatchCommandsResponse_Response_Import struct {
	Import *kvrpcpb.ImportResponse `protobuf:"bytes,5,opt,name=Import,oneof"`
}
type BatchCommandsResponse_Response_Cleanup struct {
	Cleanup *kvrpcpb.CleanupResponse `protobuf:"bytes,6,opt,name=Cleanup,oneof"`
}
type BatchCommandsResponse_Response_BatchGet struct {
	BatchGet *kvrpcpb.BatchGetResponse `protobuf:"bytes,7,opt,name=BatchGet,oneof"`
}
type BatchCommandsResponse_Response_BatchRollback struct {
	BatchRollback *kvrpcpb.BatchRollbackResponse `protobuf:"bytes,8,opt,name=BatchRollback,oneof"`
}
type BatchCommandsResponse_Response_ScanLock struct {
	ScanLock *kvrpcpb.ScanLockResponse `protobuf:"bytes,9,opt,name=ScanLock,oneof"`
}
type BatchCommandsResponse_Response_ResolveLock struct {
	ResolveLock *kvrpcpb.ResolveLockResponse `protobuf:"bytes,10,opt,name=ResolveLock,oneof"`
}
type BatchCommandsResponse_Response_GC struct {
	GC *kvrpcpb.GCResponse `protobuf:"bytes,11,opt,name=GC,oneof"`
}
type BatchCommandsResponse_Response_DeleteRange struct {
	DeleteRange *kvrpcpb.DeleteRangeResponse `protobuf:"bytes,12,opt,name=DeleteRange,oneof"`
}
type BatchCommandsResponse_Response_RawGet struct {
	RawGet *kvrpcpb.RawGetResponse `protobuf:"bytes,13,opt,name=RawGet,oneof"`
}
type BatchCommandsResponse_Response_RawBatchGet struct {
	RawBatchGet *kvrpcpb.RawBatchGetResponse `protobuf:"bytes,14,opt,name=RawBatchGet,oneof"`
}
type BatchCommandsResponse_Response_RawPut struct {
	RawPut *kvrpcpb.RawPutResponse `protobuf:"bytes,15,opt,name=RawPut,oneof"`
}
type BatchCommandsResponse_Response_RawBatchPut struct {
	RawBatchPut *kvrpcpb.RawBatchPutResponse `protobuf:"bytes,16,opt,name=RawBatchPut,oneof"`
}
type BatchCommandsResponse_Response_RawDelete struct {
	RawDelete *kvrpcpb.RawDeleteResponse `protobuf:"bytes,17,opt,name=RawDelete,oneof"`
}
type BatchCommandsResponse_Response_RawBatchDelete struct {
	RawBatchDelete *kvrpcpb.RawBatchDeleteResponse `protobuf:"bytes,18,opt,name=RawBatchDelete,oneof"`
}
type BatchCommandsResponse_Response_RawScan struct {
	RawScan *kvrpcpb.RawScanResponse `protobuf:"bytes,19,opt,name=RawScan,oneof"`
}
type BatchCommandsResponse_Response_RawDeleteRange struct {
	RawDeleteRange *kvrpcpb.RawDeleteRangeResponse `protobuf:"bytes,20,opt,name=RawDeleteRange,oneof"`
}
type BatchCommandsResponse_Response_RawBatchScan struct {
	RawBatchScan *kvrpcpb.RawBatchScanResponse `protobuf:"bytes,21,opt,name=RawBatchScan,oneof"`
}
type BatchCommandsResponse_Response_Coprocessor struct {
	Coprocessor *coprocessor.Response `protobuf:"bytes,22,opt,name=Coprocessor,oneof"`
}
type BatchCommandsResponse_Response_PessimisticLock struct {
	PessimisticLock *kvrpcpb.PessimisticLockResponse `protobuf:"bytes,23,opt,name=PessimisticLock,oneof"`
}
type BatchCommandsResponse_Response_PessimisticRollback struct {
	PessimisticRollback *kvrpcpb.PessimisticRollbackResponse `protobuf:"bytes,24,opt,name=PessimisticRollback,oneof"`
}
type BatchCommandsResponse_Response_CheckTxnStatus struct {
	CheckTxnStatus *kvrpcpb.CheckTxnStatusResponse `protobuf:"bytes,25,opt,name=CheckTxnStatus,oneof"`
}
type BatchCommandsResponse_Response_TxnHeartBeat struct {
	TxnHeartBeat *kvrpcpb.TxnHeartBeatResponse `protobuf:"bytes,26,opt,name=TxnHeartBeat,oneof"`
}
type BatchCommandsResponse_Response_Empty struct {
	Empty *BatchCommandsEmptyResponse `protobuf:"bytes,255,opt,name=Empty,oneof"`
}

func (*BatchCommandsResponse_Response_Get) isBatchCommandsResponse_Response_Cmd()                 {}
func (*BatchCommandsResponse_Response_Scan) isBatchCommandsResponse_Response_Cmd()                {}
func (*BatchCommandsResponse_Response_Prewrite) isBatchCommandsResponse_Response_Cmd()            {}
func (*BatchCommandsResponse_Response_Commit) isBatchCommandsResponse_Response_Cmd()              {}
func (*BatchCommandsResponse_Response_Import) isBatchCommandsResponse_Response_Cmd()              {}
func (*BatchCommandsResponse_Response_Cleanup) isBatchCommandsResponse_Response_Cmd()             {}
func (*BatchCommandsResponse_Response_BatchGet) isBatchCommandsResponse_Response_Cmd()            {}
func (*BatchCommandsResponse_Response_BatchRollback) isBatchCommandsResponse_Response_Cmd()       {}
func (*BatchCommandsResponse_Response_ScanLock) isBatchCommandsResponse_Response_Cmd()            {}
func (*BatchCommandsResponse_Response_ResolveLock) isBatchCommandsResponse_Response_Cmd()         {}
func (*BatchCommandsResponse_Response_GC) isBatchCommandsResponse_Response_Cmd()                  {}
func (*BatchCommandsResponse_Response_DeleteRange) isBatchCommandsResponse_Response_Cmd()         {}
func (*BatchCommandsResponse_Response_RawGet) isBatchCommandsResponse_Response_Cmd()              {}
func (*BatchCommandsResponse_Response_RawBatchGet) isBatchCommandsResponse_Response_Cmd()         {}
func (*BatchCommandsResponse_Response_RawPut) isBatchCommandsResponse_Response_Cmd()              {}
func (*BatchCommandsResponse_Response_RawBatchPut) isBatchCommandsResponse_Response_Cmd()         {}
func (*BatchCommandsResponse_Response_RawDelete) isBatchCommandsResponse_Response_Cmd()           {}
func (*BatchCommandsResponse_Response_RawBatchDelete) isBatchCommandsResponse_Response_Cmd()      {}
func (*BatchCommandsResponse_Response_RawScan) isBatchCommandsResponse_Response_Cmd()             {}
func (*BatchCommandsResponse_Response_RawDeleteRange) isBatchCommandsResponse_Response_Cmd()      {}
func (*BatchCommandsResponse_Response_RawBatchScan) isBatchCommandsResponse_Response_Cmd()        {}
func (*BatchCommandsResponse_Response_Coprocessor) isBatchCommandsResponse_Response_Cmd()         {}
func (*BatchCommandsResponse_Response_PessimisticLock) isBatchCommandsResponse_Response_Cmd()     {}
func (*BatchCommandsResponse_Response_PessimisticRollback) isBatchCommandsResponse_Response_Cmd() {}
func (*BatchCommandsResponse_Response_CheckTxnStatus) isBatchCommandsResponse_Response_Cmd()      {}
func (*BatchCommandsResponse_Response_TxnHeartBeat) isBatchCommandsResponse_Response_Cmd()        {}
func (*BatchCommandsResponse_Response_Empty) isBatchCommandsResponse_Response_Cmd()               {}

func (m *BatchCommandsResponse_Response) GetCmd() isBatchCommandsResponse_Response_Cmd {
	if m != nil {
		return m.Cmd
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetGet() *kvrpcpb.GetResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Get); ok {
		return x.Get
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetScan() *kvrpcpb.ScanResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Scan); ok {
		return x.Scan
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetPrewrite() *kvrpcpb.PrewriteResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Prewrite); ok {
		return x.Prewrite
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetCommit() *kvrpcpb.CommitResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Commit); ok {
		return x.Commit
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetImport() *kvrpcpb.ImportResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Import); ok {
		return x.Import
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetCleanup() *kvrpcpb.CleanupResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Cleanup); ok {
		return x.Cleanup
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetBatchGet() *kvrpcpb.BatchGetResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_BatchGet); ok {
		return x.BatchGet
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetBatchRollback() *kvrpcpb.BatchRollbackResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_BatchRollback); ok {
		return x.BatchRollback
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetScanLock() *kvrpcpb.ScanLockResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_ScanLock); ok {
		return x.ScanLock
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetResolveLock() *kvrpcpb.ResolveLockResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_ResolveLock); ok {
		return x.ResolveLock
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetGC() *kvrpcpb.GCResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_GC); ok {
		return x.GC
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetDeleteRange() *kvrpcpb.DeleteRangeResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_DeleteRange); ok {
		return x.DeleteRange
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawGet() *kvrpcpb.RawGetResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawGet); ok {
		return x.RawGet
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawBatchGet() *kvrpcpb.RawBatchGetResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawBatchGet); ok {
		return x.RawBatchGet
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawPut() *kvrpcpb.RawPutResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawPut); ok {
		return x.RawPut
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawBatchPut() *kvrpcpb.RawBatchPutResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawBatchPut); ok {
		return x.RawBatchPut
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawDelete() *kvrpcpb.RawDeleteResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawDelete); ok {
		return x.RawDelete
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawBatchDelete() *kvrpcpb.RawBatchDeleteResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawBatchDelete); ok {
		return x.RawBatchDelete
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawScan() *kvrpcpb.RawScanResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawScan); ok {
		return x.RawScan
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawDeleteRange() *kvrpcpb.RawDeleteRangeResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawDeleteRange); ok {
		return x.RawDeleteRange
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetRawBatchScan() *kvrpcpb.RawBatchScanResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_RawBatchScan); ok {
		return x.RawBatchScan
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetCoprocessor() *coprocessor.Response {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Coprocessor); ok {
		return x.Coprocessor
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetPessimisticLock() *kvrpcpb.PessimisticLockResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_PessimisticLock); ok {
		return x.PessimisticLock
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetPessimisticRollback() *kvrpcpb.PessimisticRollbackResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_PessimisticRollback); ok {
		return x.PessimisticRollback
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetCheckTxnStatus() *kvrpcpb.CheckTxnStatusResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_CheckTxnStatus); ok {
		return x.CheckTxnStatus
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetTxnHeartBeat() *kvrpcpb.TxnHeartBeatResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_TxnHeartBeat); ok {
		return x.TxnHeartBeat
	}
	return nil
}

func (m *BatchCommandsResponse_Response) GetEmpty() *BatchCommandsEmptyResponse {
	if x, ok := m.GetCmd().(*BatchCommandsResponse_Response_Empty); ok {
		return x.Empty
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*BatchCommandsResponse_Response) 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 _BatchCommandsResponse_Response_OneofMarshaler, _BatchCommandsResponse_Response_OneofUnmarshaler, _BatchCommandsResponse_Response_OneofSizer, []interface{}{
		(*BatchCommandsResponse_Response_Get)(nil),
		(*BatchCommandsResponse_Response_Scan)(nil),
		(*BatchCommandsResponse_Response_Prewrite)(nil),
		(*BatchCommandsResponse_Response_Commit)(nil),
		(*BatchCommandsResponse_Response_Import)(nil),
		(*BatchCommandsResponse_Response_Cleanup)(nil),
		(*BatchCommandsResponse_Response_BatchGet)(nil),
		(*BatchCommandsResponse_Response_BatchRollback)(nil),
		(*BatchCommandsResponse_Response_ScanLock)(nil),
		(*BatchCommandsResponse_Response_ResolveLock)(nil),
		(*BatchCommandsResponse_Response_GC)(nil),
		(*BatchCommandsResponse_Response_DeleteRange)(nil),
		(*BatchCommandsResponse_Response_RawGet)(nil),
		(*BatchCommandsResponse_Response_RawBatchGet)(nil),
		(*BatchCommandsResponse_Response_RawPut)(nil),
		(*BatchCommandsResponse_Response_RawBatchPut)(nil),
		(*BatchCommandsResponse_Response_RawDelete)(nil),
		(*BatchCommandsResponse_Response_RawBatchDelete)(nil),
		(*BatchCommandsResponse_Response_RawScan)(nil),
		(*BatchCommandsResponse_Response_RawDeleteRange)(nil),
		(*BatchCommandsResponse_Response_RawBatchScan)(nil),
		(*BatchCommandsResponse_Response_Coprocessor)(nil),
		(*BatchCommandsResponse_Response_PessimisticLock)(nil),
		(*BatchCommandsResponse_Response_PessimisticRollback)(nil),
		(*BatchCommandsResponse_Response_CheckTxnStatus)(nil),
		(*BatchCommandsResponse_Response_TxnHeartBeat)(nil),
		(*BatchCommandsResponse_Response_Empty)(nil),
	}
}

func _BatchCommandsResponse_Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*BatchCommandsResponse_Response)
	// cmd
	switch x := m.Cmd.(type) {
	case *BatchCommandsResponse_Response_Get:
		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Get); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_Scan:
		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Scan); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_Prewrite:
		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Prewrite); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_Commit:
		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Commit); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_Import:
		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Import); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_Cleanup:
		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Cleanup); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_BatchGet:
		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BatchGet); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_BatchRollback:
		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BatchRollback); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_ScanLock:
		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ScanLock); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_ResolveLock:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ResolveLock); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_GC:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.GC); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_DeleteRange:
		_ = b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DeleteRange); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawGet:
		_ = b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawGet); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawBatchGet:
		_ = b.EncodeVarint(14<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawBatchGet); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawPut:
		_ = b.EncodeVarint(15<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawPut); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawBatchPut:
		_ = b.EncodeVarint(16<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawBatchPut); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawDelete:
		_ = b.EncodeVarint(17<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawDelete); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawBatchDelete:
		_ = b.EncodeVarint(18<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawBatchDelete); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawScan:
		_ = b.EncodeVarint(19<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawScan); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawDeleteRange:
		_ = b.EncodeVarint(20<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawDeleteRange); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_RawBatchScan:
		_ = b.EncodeVarint(21<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RawBatchScan); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_Coprocessor:
		_ = b.EncodeVarint(22<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Coprocessor); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_PessimisticLock:
		_ = b.EncodeVarint(23<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PessimisticLock); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_PessimisticRollback:
		_ = b.EncodeVarint(24<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.PessimisticRollback); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_CheckTxnStatus:
		_ = b.EncodeVarint(25<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.CheckTxnStatus); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_TxnHeartBeat:
		_ = b.EncodeVarint(26<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.TxnHeartBeat); err != nil {
			return err
		}
	case *BatchCommandsResponse_Response_Empty:
		_ = b.EncodeVarint(255<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Empty); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("BatchCommandsResponse_Response.Cmd has unexpected type %T", x)
	}
	return nil
}

func _BatchCommandsResponse_Response_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*BatchCommandsResponse_Response)
	switch tag {
	case 1: // cmd.Get
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.GetResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_Get{msg}
		return true, err
	case 2: // cmd.Scan
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.ScanResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_Scan{msg}
		return true, err
	case 3: // cmd.Prewrite
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.PrewriteResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_Prewrite{msg}
		return true, err
	case 4: // cmd.Commit
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.CommitResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_Commit{msg}
		return true, err
	case 5: // cmd.Import
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.ImportResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_Import{msg}
		return true, err
	case 6: // cmd.Cleanup
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.CleanupResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_Cleanup{msg}
		return true, err
	case 7: // cmd.BatchGet
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.BatchGetResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_BatchGet{msg}
		return true, err
	case 8: // cmd.BatchRollback
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.BatchRollbackResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_BatchRollback{msg}
		return true, err
	case 9: // cmd.ScanLock
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.ScanLockResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_ScanLock{msg}
		return true, err
	case 10: // cmd.ResolveLock
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.ResolveLockResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_ResolveLock{msg}
		return true, err
	case 11: // cmd.GC
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.GCResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_GC{msg}
		return true, err
	case 12: // cmd.DeleteRange
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.DeleteRangeResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_DeleteRange{msg}
		return true, err
	case 13: // cmd.RawGet
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawGetResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawGet{msg}
		return true, err
	case 14: // cmd.RawBatchGet
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawBatchGetResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawBatchGet{msg}
		return true, err
	case 15: // cmd.RawPut
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawPutResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawPut{msg}
		return true, err
	case 16: // cmd.RawBatchPut
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawBatchPutResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawBatchPut{msg}
		return true, err
	case 17: // cmd.RawDelete
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawDeleteResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawDelete{msg}
		return true, err
	case 18: // cmd.RawBatchDelete
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawBatchDeleteResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawBatchDelete{msg}
		return true, err
	case 19: // cmd.RawScan
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawScanResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawScan{msg}
		return true, err
	case 20: // cmd.RawDeleteRange
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawDeleteRangeResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawDeleteRange{msg}
		return true, err
	case 21: // cmd.RawBatchScan
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.RawBatchScanResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_RawBatchScan{msg}
		return true, err
	case 22: // cmd.Coprocessor
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(coprocessor.Response)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_Coprocessor{msg}
		return true, err
	case 23: // cmd.PessimisticLock
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.PessimisticLockResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_PessimisticLock{msg}
		return true, err
	case 24: // cmd.PessimisticRollback
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.PessimisticRollbackResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_PessimisticRollback{msg}
		return true, err
	case 25: // cmd.CheckTxnStatus
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.CheckTxnStatusResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_CheckTxnStatus{msg}
		return true, err
	case 26: // cmd.TxnHeartBeat
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(kvrpcpb.TxnHeartBeatResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_TxnHeartBeat{msg}
		return true, err
	case 255: // cmd.Empty
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(BatchCommandsEmptyResponse)
		err := b.DecodeMessage(msg)
		m.Cmd = &BatchCommandsResponse_Response_Empty{msg}
		return true, err
	default:
		return false, nil
	}
}

func _BatchCommandsResponse_Response_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*BatchCommandsResponse_Response)
	// cmd
	switch x := m.Cmd.(type) {
	case *BatchCommandsResponse_Response_Get:
		s := proto.Size(x.Get)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_Scan:
		s := proto.Size(x.Scan)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_Prewrite:
		s := proto.Size(x.Prewrite)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_Commit:
		s := proto.Size(x.Commit)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_Import:
		s := proto.Size(x.Import)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_Cleanup:
		s := proto.Size(x.Cleanup)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_BatchGet:
		s := proto.Size(x.BatchGet)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_BatchRollback:
		s := proto.Size(x.BatchRollback)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_ScanLock:
		s := proto.Size(x.ScanLock)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_ResolveLock:
		s := proto.Size(x.ResolveLock)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_GC:
		s := proto.Size(x.GC)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_DeleteRange:
		s := proto.Size(x.DeleteRange)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawGet:
		s := proto.Size(x.RawGet)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawBatchGet:
		s := proto.Size(x.RawBatchGet)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawPut:
		s := proto.Size(x.RawPut)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawBatchPut:
		s := proto.Size(x.RawBatchPut)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawDelete:
		s := proto.Size(x.RawDelete)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawBatchDelete:
		s := proto.Size(x.RawBatchDelete)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawScan:
		s := proto.Size(x.RawScan)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawDeleteRange:
		s := proto.Size(x.RawDeleteRange)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_RawBatchScan:
		s := proto.Size(x.RawBatchScan)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_Coprocessor:
		s := proto.Size(x.Coprocessor)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_PessimisticLock:
		s := proto.Size(x.PessimisticLock)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_PessimisticRollback:
		s := proto.Size(x.PessimisticRollback)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_CheckTxnStatus:
		s := proto.Size(x.CheckTxnStatus)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_TxnHeartBeat:
		s := proto.Size(x.TxnHeartBeat)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *BatchCommandsResponse_Response_Empty:
		s := proto.Size(x.Empty)
		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
}

type BatchRaftMessage struct {
	Msgs                 []*raft_serverpb.RaftMessage `protobuf:"bytes,1,rep,name=msgs" json:"msgs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

var xxx_messageInfo_BatchRaftMessage proto.InternalMessageInfo

func (m *BatchRaftMessage) GetMsgs() []*raft_serverpb.RaftMessage {
	if m != nil {
		return m.Msgs
	}
	return nil
}

type BatchCommandsEmptyRequest struct {
	// ID of the test request.
	TestId uint64 `protobuf:"varint,1,opt,name=test_id,json=testId,proto3" json:"test_id,omitempty"`
	// TiKV needs to delay at least such a time to response the client.
	DelayTime            uint64   `protobuf:"varint,2,opt,name=delay_time,json=delayTime,proto3" json:"delay_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_BatchCommandsEmptyRequest proto.InternalMessageInfo

func (m *BatchCommandsEmptyRequest) GetTestId() uint64 {
	if m != nil {
		return m.TestId
	}
	return 0
}

func (m *BatchCommandsEmptyRequest) GetDelayTime() uint64 {
	if m != nil {
		return m.DelayTime
	}
	return 0
}

type BatchCommandsEmptyResponse struct {
	// ID of the test request.
	TestId               uint64   `protobuf:"varint,1,opt,name=test_id,json=testId,proto3" json:"test_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_BatchCommandsEmptyResponse proto.InternalMessageInfo

func (m *BatchCommandsEmptyResponse) GetTestId() uint64 {
	if m != nil {
		return m.TestId
	}
	return 0
}

func init() {
	proto.RegisterType((*BatchCommandsRequest)(nil), "tikvpb.BatchCommandsRequest")
	proto.RegisterType((*BatchCommandsRequest_Request)(nil), "tikvpb.BatchCommandsRequest.Request")
	proto.RegisterType((*BatchCommandsResponse)(nil), "tikvpb.BatchCommandsResponse")
	proto.RegisterType((*BatchCommandsResponse_Response)(nil), "tikvpb.BatchCommandsResponse.Response")
	proto.RegisterType((*BatchRaftMessage)(nil), "tikvpb.BatchRaftMessage")
	proto.RegisterType((*BatchCommandsEmptyRequest)(nil), "tikvpb.BatchCommandsEmptyRequest")
	proto.RegisterType((*BatchCommandsEmptyResponse)(nil), "tikvpb.BatchCommandsEmptyResponse")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// Client API for Tikv service

type TikvClient interface {
	// KV commands with mvcc/txn supported.
	KvGet(ctx context.Context, in *kvrpcpb.GetRequest, opts ...grpc.CallOption) (*kvrpcpb.GetResponse, error)
	KvScan(ctx context.Context, in *kvrpcpb.ScanRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanResponse, error)
	KvPrewrite(ctx context.Context, in *kvrpcpb.PrewriteRequest, opts ...grpc.CallOption) (*kvrpcpb.PrewriteResponse, error)
	KvPessimisticLock(ctx context.Context, in *kvrpcpb.PessimisticLockRequest, opts ...grpc.CallOption) (*kvrpcpb.PessimisticLockResponse, error)
	KVPessimisticRollback(ctx context.Context, in *kvrpcpb.PessimisticRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.PessimisticRollbackResponse, error)
	KvTxnHeartBeat(ctx context.Context, in *kvrpcpb.TxnHeartBeatRequest, opts ...grpc.CallOption) (*kvrpcpb.TxnHeartBeatResponse, error)
	KvCheckTxnStatus(ctx context.Context, in *kvrpcpb.CheckTxnStatusRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckTxnStatusResponse, error)
	KvCommit(ctx context.Context, in *kvrpcpb.CommitRequest, opts ...grpc.CallOption) (*kvrpcpb.CommitResponse, error)
	KvImport(ctx context.Context, in *kvrpcpb.ImportRequest, opts ...grpc.CallOption) (*kvrpcpb.ImportResponse, error)
	KvCleanup(ctx context.Context, in *kvrpcpb.CleanupRequest, opts ...grpc.CallOption) (*kvrpcpb.CleanupResponse, error)
	KvBatchGet(ctx context.Context, in *kvrpcpb.BatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchGetResponse, error)
	KvBatchRollback(ctx context.Context, in *kvrpcpb.BatchRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchRollbackResponse, error)
	KvScanLock(ctx context.Context, in *kvrpcpb.ScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanLockResponse, error)
	KvResolveLock(ctx context.Context, in *kvrpcpb.ResolveLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ResolveLockResponse, error)
	KvGC(ctx context.Context, in *kvrpcpb.GCRequest, opts ...grpc.CallOption) (*kvrpcpb.GCResponse, error)
	KvDeleteRange(ctx context.Context, in *kvrpcpb.DeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.DeleteRangeResponse, error)
	// RawKV commands.
	RawGet(ctx context.Context, in *kvrpcpb.RawGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawGetResponse, error)
	RawBatchGet(ctx context.Context, in *kvrpcpb.RawBatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchGetResponse, error)
	RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawPutResponse, error)
	RawBatchPut(ctx context.Context, in *kvrpcpb.RawBatchPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchPutResponse, error)
	RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteResponse, error)
	RawBatchDelete(ctx context.Context, in *kvrpcpb.RawBatchDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchDeleteResponse, error)
	RawScan(ctx context.Context, in *kvrpcpb.RawScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawScanResponse, error)
	RawDeleteRange(ctx context.Context, in *kvrpcpb.RawDeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteRangeResponse, error)
	RawBatchScan(ctx context.Context, in *kvrpcpb.RawBatchScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchScanResponse, error)
	// Store commands (to the whole tikv but not a certain region)
	UnsafeDestroyRange(ctx context.Context, in *kvrpcpb.UnsafeDestroyRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.UnsafeDestroyRangeResponse, error)
	RegisterLockObserver(ctx context.Context, in *kvrpcpb.RegisterLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.RegisterLockObserverResponse, error)
	CheckLockObserver(ctx context.Context, in *kvrpcpb.CheckLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckLockObserverResponse, error)
	RemoveLockObserver(ctx context.Context, in *kvrpcpb.RemoveLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.RemoveLockObserverResponse, error)
	PhysicalScanLock(ctx context.Context, in *kvrpcpb.PhysicalScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.PhysicalScanLockResponse, error)
	// SQL push down commands.
	Coprocessor(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (*coprocessor.Response, error)
	CoprocessorStream(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (Tikv_CoprocessorStreamClient, error)
	BatchCoprocessor(ctx context.Context, in *coprocessor.BatchRequest, opts ...grpc.CallOption) (Tikv_BatchCoprocessorClient, error)
	// Raft commands (tikv <-> tikv).
	Raft(ctx context.Context, opts ...grpc.CallOption) (Tikv_RaftClient, error)
	BatchRaft(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchRaftClient, error)
	Snapshot(ctx context.Context, opts ...grpc.CallOption) (Tikv_SnapshotClient, error)
	// Region commands.
	SplitRegion(ctx context.Context, in *kvrpcpb.SplitRegionRequest, opts ...grpc.CallOption) (*kvrpcpb.SplitRegionResponse, error)
	ReadIndex(ctx context.Context, in *kvrpcpb.ReadIndexRequest, opts ...grpc.CallOption) (*kvrpcpb.ReadIndexResponse, error)
	// transaction debugger commands.
	MvccGetByKey(ctx context.Context, in *kvrpcpb.MvccGetByKeyRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByKeyResponse, error)
	MvccGetByStartTs(ctx context.Context, in *kvrpcpb.MvccGetByStartTsRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByStartTsResponse, error)
	BatchCommands(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchCommandsClient, error)
}

type tikvClient struct {
	cc *grpc.ClientConn
}

func NewTikvClient(cc *grpc.ClientConn) TikvClient {
	return &tikvClient{cc}
}

func (c *tikvClient) KvGet(ctx context.Context, in *kvrpcpb.GetRequest, opts ...grpc.CallOption) (*kvrpcpb.GetResponse, error) {
	out := new(kvrpcpb.GetResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvScan(ctx context.Context, in *kvrpcpb.ScanRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanResponse, error) {
	out := new(kvrpcpb.ScanResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvScan", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvPrewrite(ctx context.Context, in *kvrpcpb.PrewriteRequest, opts ...grpc.CallOption) (*kvrpcpb.PrewriteResponse, error) {
	out := new(kvrpcpb.PrewriteResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvPrewrite", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvPessimisticLock(ctx context.Context, in *kvrpcpb.PessimisticLockRequest, opts ...grpc.CallOption) (*kvrpcpb.PessimisticLockResponse, error) {
	out := new(kvrpcpb.PessimisticLockResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvPessimisticLock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KVPessimisticRollback(ctx context.Context, in *kvrpcpb.PessimisticRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.PessimisticRollbackResponse, error) {
	out := new(kvrpcpb.PessimisticRollbackResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KVPessimisticRollback", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvTxnHeartBeat(ctx context.Context, in *kvrpcpb.TxnHeartBeatRequest, opts ...grpc.CallOption) (*kvrpcpb.TxnHeartBeatResponse, error) {
	out := new(kvrpcpb.TxnHeartBeatResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvTxnHeartBeat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvCheckTxnStatus(ctx context.Context, in *kvrpcpb.CheckTxnStatusRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckTxnStatusResponse, error) {
	out := new(kvrpcpb.CheckTxnStatusResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCheckTxnStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvCommit(ctx context.Context, in *kvrpcpb.CommitRequest, opts ...grpc.CallOption) (*kvrpcpb.CommitResponse, error) {
	out := new(kvrpcpb.CommitResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCommit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvImport(ctx context.Context, in *kvrpcpb.ImportRequest, opts ...grpc.CallOption) (*kvrpcpb.ImportResponse, error) {
	out := new(kvrpcpb.ImportResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvImport", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvCleanup(ctx context.Context, in *kvrpcpb.CleanupRequest, opts ...grpc.CallOption) (*kvrpcpb.CleanupResponse, error) {
	out := new(kvrpcpb.CleanupResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvCleanup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvBatchGet(ctx context.Context, in *kvrpcpb.BatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchGetResponse, error) {
	out := new(kvrpcpb.BatchGetResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvBatchGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvBatchRollback(ctx context.Context, in *kvrpcpb.BatchRollbackRequest, opts ...grpc.CallOption) (*kvrpcpb.BatchRollbackResponse, error) {
	out := new(kvrpcpb.BatchRollbackResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvBatchRollback", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvScanLock(ctx context.Context, in *kvrpcpb.ScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ScanLockResponse, error) {
	out := new(kvrpcpb.ScanLockResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvScanLock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvResolveLock(ctx context.Context, in *kvrpcpb.ResolveLockRequest, opts ...grpc.CallOption) (*kvrpcpb.ResolveLockResponse, error) {
	out := new(kvrpcpb.ResolveLockResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvResolveLock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvGC(ctx context.Context, in *kvrpcpb.GCRequest, opts ...grpc.CallOption) (*kvrpcpb.GCResponse, error) {
	out := new(kvrpcpb.GCResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvGC", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) KvDeleteRange(ctx context.Context, in *kvrpcpb.DeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.DeleteRangeResponse, error) {
	out := new(kvrpcpb.DeleteRangeResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/KvDeleteRange", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawGet(ctx context.Context, in *kvrpcpb.RawGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawGetResponse, error) {
	out := new(kvrpcpb.RawGetResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawBatchGet(ctx context.Context, in *kvrpcpb.RawBatchGetRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchGetResponse, error) {
	out := new(kvrpcpb.RawBatchGetResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchGet", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawPut(ctx context.Context, in *kvrpcpb.RawPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawPutResponse, error) {
	out := new(kvrpcpb.RawPutResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawPut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawBatchPut(ctx context.Context, in *kvrpcpb.RawBatchPutRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchPutResponse, error) {
	out := new(kvrpcpb.RawBatchPutResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchPut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawDelete(ctx context.Context, in *kvrpcpb.RawDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteResponse, error) {
	out := new(kvrpcpb.RawDeleteResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawBatchDelete(ctx context.Context, in *kvrpcpb.RawBatchDeleteRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchDeleteResponse, error) {
	out := new(kvrpcpb.RawBatchDeleteResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchDelete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawScan(ctx context.Context, in *kvrpcpb.RawScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawScanResponse, error) {
	out := new(kvrpcpb.RawScanResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawScan", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawDeleteRange(ctx context.Context, in *kvrpcpb.RawDeleteRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.RawDeleteRangeResponse, error) {
	out := new(kvrpcpb.RawDeleteRangeResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawDeleteRange", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RawBatchScan(ctx context.Context, in *kvrpcpb.RawBatchScanRequest, opts ...grpc.CallOption) (*kvrpcpb.RawBatchScanResponse, error) {
	out := new(kvrpcpb.RawBatchScanResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RawBatchScan", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) UnsafeDestroyRange(ctx context.Context, in *kvrpcpb.UnsafeDestroyRangeRequest, opts ...grpc.CallOption) (*kvrpcpb.UnsafeDestroyRangeResponse, error) {
	out := new(kvrpcpb.UnsafeDestroyRangeResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/UnsafeDestroyRange", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RegisterLockObserver(ctx context.Context, in *kvrpcpb.RegisterLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.RegisterLockObserverResponse, error) {
	out := new(kvrpcpb.RegisterLockObserverResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RegisterLockObserver", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) CheckLockObserver(ctx context.Context, in *kvrpcpb.CheckLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.CheckLockObserverResponse, error) {
	out := new(kvrpcpb.CheckLockObserverResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/CheckLockObserver", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) RemoveLockObserver(ctx context.Context, in *kvrpcpb.RemoveLockObserverRequest, opts ...grpc.CallOption) (*kvrpcpb.RemoveLockObserverResponse, error) {
	out := new(kvrpcpb.RemoveLockObserverResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/RemoveLockObserver", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) PhysicalScanLock(ctx context.Context, in *kvrpcpb.PhysicalScanLockRequest, opts ...grpc.CallOption) (*kvrpcpb.PhysicalScanLockResponse, error) {
	out := new(kvrpcpb.PhysicalScanLockResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/PhysicalScanLock", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) Coprocessor(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (*coprocessor.Response, error) {
	out := new(coprocessor.Response)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/Coprocessor", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) CoprocessorStream(ctx context.Context, in *coprocessor.Request, opts ...grpc.CallOption) (Tikv_CoprocessorStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[0], "/tikvpb.Tikv/CoprocessorStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &tikvCoprocessorStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Tikv_CoprocessorStreamClient interface {
	Recv() (*coprocessor.Response, error)
	grpc.ClientStream
}

type tikvCoprocessorStreamClient struct {
	grpc.ClientStream
}

func (x *tikvCoprocessorStreamClient) Recv() (*coprocessor.Response, error) {
	m := new(coprocessor.Response)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *tikvClient) BatchCoprocessor(ctx context.Context, in *coprocessor.BatchRequest, opts ...grpc.CallOption) (Tikv_BatchCoprocessorClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[1], "/tikvpb.Tikv/BatchCoprocessor", opts...)
	if err != nil {
		return nil, err
	}
	x := &tikvBatchCoprocessorClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Tikv_BatchCoprocessorClient interface {
	Recv() (*coprocessor.BatchResponse, error)
	grpc.ClientStream
}

type tikvBatchCoprocessorClient struct {
	grpc.ClientStream
}

func (x *tikvBatchCoprocessorClient) Recv() (*coprocessor.BatchResponse, error) {
	m := new(coprocessor.BatchResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *tikvClient) Raft(ctx context.Context, opts ...grpc.CallOption) (Tikv_RaftClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[2], "/tikvpb.Tikv/Raft", opts...)
	if err != nil {
		return nil, err
	}
	x := &tikvRaftClient{stream}
	return x, nil
}

type Tikv_RaftClient interface {
	Send(*raft_serverpb.RaftMessage) error
	CloseAndRecv() (*raft_serverpb.Done, error)
	grpc.ClientStream
}

type tikvRaftClient struct {
	grpc.ClientStream
}

func (x *tikvRaftClient) Send(m *raft_serverpb.RaftMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *tikvRaftClient) CloseAndRecv() (*raft_serverpb.Done, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(raft_serverpb.Done)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *tikvClient) BatchRaft(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchRaftClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[3], "/tikvpb.Tikv/BatchRaft", opts...)
	if err != nil {
		return nil, err
	}
	x := &tikvBatchRaftClient{stream}
	return x, nil
}

type Tikv_BatchRaftClient interface {
	Send(*BatchRaftMessage) error
	CloseAndRecv() (*raft_serverpb.Done, error)
	grpc.ClientStream
}

type tikvBatchRaftClient struct {
	grpc.ClientStream
}

func (x *tikvBatchRaftClient) Send(m *BatchRaftMessage) error {
	return x.ClientStream.SendMsg(m)
}

func (x *tikvBatchRaftClient) CloseAndRecv() (*raft_serverpb.Done, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(raft_serverpb.Done)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *tikvClient) Snapshot(ctx context.Context, opts ...grpc.CallOption) (Tikv_SnapshotClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[4], "/tikvpb.Tikv/Snapshot", opts...)
	if err != nil {
		return nil, err
	}
	x := &tikvSnapshotClient{stream}
	return x, nil
}

type Tikv_SnapshotClient interface {
	Send(*raft_serverpb.SnapshotChunk) error
	CloseAndRecv() (*raft_serverpb.Done, error)
	grpc.ClientStream
}

type tikvSnapshotClient struct {
	grpc.ClientStream
}

func (x *tikvSnapshotClient) Send(m *raft_serverpb.SnapshotChunk) error {
	return x.ClientStream.SendMsg(m)
}

func (x *tikvSnapshotClient) CloseAndRecv() (*raft_serverpb.Done, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(raft_serverpb.Done)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *tikvClient) SplitRegion(ctx context.Context, in *kvrpcpb.SplitRegionRequest, opts ...grpc.CallOption) (*kvrpcpb.SplitRegionResponse, error) {
	out := new(kvrpcpb.SplitRegionResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/SplitRegion", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) ReadIndex(ctx context.Context, in *kvrpcpb.ReadIndexRequest, opts ...grpc.CallOption) (*kvrpcpb.ReadIndexResponse, error) {
	out := new(kvrpcpb.ReadIndexResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/ReadIndex", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) MvccGetByKey(ctx context.Context, in *kvrpcpb.MvccGetByKeyRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByKeyResponse, error) {
	out := new(kvrpcpb.MvccGetByKeyResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/MvccGetByKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) MvccGetByStartTs(ctx context.Context, in *kvrpcpb.MvccGetByStartTsRequest, opts ...grpc.CallOption) (*kvrpcpb.MvccGetByStartTsResponse, error) {
	out := new(kvrpcpb.MvccGetByStartTsResponse)
	err := c.cc.Invoke(ctx, "/tikvpb.Tikv/MvccGetByStartTs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tikvClient) BatchCommands(ctx context.Context, opts ...grpc.CallOption) (Tikv_BatchCommandsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Tikv_serviceDesc.Streams[5], "/tikvpb.Tikv/BatchCommands", opts...)
	if err != nil {
		return nil, err
	}
	x := &tikvBatchCommandsClient{stream}
	return x, nil
}

type Tikv_BatchCommandsClient interface {
	Send(*BatchCommandsRequest) error
	Recv() (*BatchCommandsResponse, error)
	grpc.ClientStream
}

type tikvBatchCommandsClient struct {
	grpc.ClientStream
}

func (x *tikvBatchCommandsClient) Send(m *BatchCommandsRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *tikvBatchCommandsClient) Recv() (*BatchCommandsResponse, error) {
	m := new(BatchCommandsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for Tikv service

type TikvServer interface {
	// KV commands with mvcc/txn supported.
	KvGet(context.Context, *kvrpcpb.GetRequest) (*kvrpcpb.GetResponse, error)
	KvScan(context.Context, *kvrpcpb.ScanRequest) (*kvrpcpb.ScanResponse, error)
	KvPrewrite(context.Context, *kvrpcpb.PrewriteRequest) (*kvrpcpb.PrewriteResponse, error)
	KvPessimisticLock(context.Context, *kvrpcpb.PessimisticLockRequest) (*kvrpcpb.PessimisticLockResponse, error)
	KVPessimisticRollback(context.Context, *kvrpcpb.PessimisticRollbackRequest) (*kvrpcpb.PessimisticRollbackResponse, error)
	KvTxnHeartBeat(context.Context, *kvrpcpb.TxnHeartBeatRequest) (*kvrpcpb.TxnHeartBeatResponse, error)
	KvCheckTxnStatus(context.Context, *kvrpcpb.CheckTxnStatusRequest) (*kvrpcpb.CheckTxnStatusResponse, error)
	KvCommit(context.Context, *kvrpcpb.CommitRequest) (*kvrpcpb.CommitResponse, error)
	KvImport(context.Context, *kvrpcpb.ImportRequest) (*kvrpcpb.ImportResponse, error)
	KvCleanup(context.Context, *kvrpcpb.CleanupRequest) (*kvrpcpb.CleanupResponse, error)
	KvBatchGet(context.Context, *kvrpcpb.BatchGetRequest) (*kvrpcpb.BatchGetResponse, error)
	KvBatchRollback(context.Context, *kvrpcpb.BatchRollbackRequest) (*kvrpcpb.BatchRollbackResponse, error)
	KvScanLock(context.Context, *kvrpcpb.ScanLockRequest) (*kvrpcpb.ScanLockResponse, error)
	KvResolveLock(context.Context, *kvrpcpb.ResolveLockRequest) (*kvrpcpb.ResolveLockResponse, error)
	KvGC(context.Context, *kvrpcpb.GCRequest) (*kvrpcpb.GCResponse, error)
	KvDeleteRange(context.Context, *kvrpcpb.DeleteRangeRequest) (*kvrpcpb.DeleteRangeResponse, error)
	// RawKV commands.
	RawGet(context.Context, *kvrpcpb.RawGetRequest) (*kvrpcpb.RawGetResponse, error)
	RawBatchGet(context.Context, *kvrpcpb.RawBatchGetRequest) (*kvrpcpb.RawBatchGetResponse, error)
	RawPut(context.Context, *kvrpcpb.RawPutRequest) (*kvrpcpb.RawPutResponse, error)
	RawBatchPut(context.Context, *kvrpcpb.RawBatchPutRequest) (*kvrpcpb.RawBatchPutResponse, error)
	RawDelete(context.Context, *kvrpcpb.RawDeleteRequest) (*kvrpcpb.RawDeleteResponse, error)
	RawBatchDelete(context.Context, *kvrpcpb.RawBatchDeleteRequest) (*kvrpcpb.RawBatchDeleteResponse, error)
	RawScan(context.Context, *kvrpcpb.RawScanRequest) (*kvrpcpb.RawScanResponse, error)
	RawDeleteRange(context.Context, *kvrpcpb.RawDeleteRangeRequest) (*kvrpcpb.RawDeleteRangeResponse, error)
	RawBatchScan(context.Context, *kvrpcpb.RawBatchScanRequest) (*kvrpcpb.RawBatchScanResponse, error)
	// Store commands (to the whole tikv but not a certain region)
	UnsafeDestroyRange(context.Context, *kvrpcpb.UnsafeDestroyRangeRequest) (*kvrpcpb.UnsafeDestroyRangeResponse, error)
	RegisterLockObserver(context.Context, *kvrpcpb.RegisterLockObserverRequest) (*kvrpcpb.RegisterLockObserverResponse, error)
	CheckLockObserver(context.Context, *kvrpcpb.CheckLockObserverRequest) (*kvrpcpb.CheckLockObserverResponse, error)
	RemoveLockObserver(context.Context, *kvrpcpb.RemoveLockObserverRequest) (*kvrpcpb.RemoveLockObserverResponse, error)
	PhysicalScanLock(context.Context, *kvrpcpb.PhysicalScanLockRequest) (*kvrpcpb.PhysicalScanLockResponse, error)
	// SQL push down commands.
	Coprocessor(context.Context, *coprocessor.Request) (*coprocessor.Response, error)
	CoprocessorStream(*coprocessor.Request, Tikv_CoprocessorStreamServer) error
	BatchCoprocessor(*coprocessor.BatchRequest, Tikv_BatchCoprocessorServer) error
	// Raft commands (tikv <-> tikv).
	Raft(Tikv_RaftServer) error
	BatchRaft(Tikv_BatchRaftServer) error
	Snapshot(Tikv_SnapshotServer) error
	// Region commands.
	SplitRegion(context.Context, *kvrpcpb.SplitRegionRequest) (*kvrpcpb.SplitRegionResponse, error)
	ReadIndex(context.Context, *kvrpcpb.ReadIndexRequest) (*kvrpcpb.ReadIndexResponse, error)
	// transaction debugger commands.
	MvccGetByKey(context.Context, *kvrpcpb.MvccGetByKeyRequest) (*kvrpcpb.MvccGetByKeyResponse, error)
	MvccGetByStartTs(context.Context, *kvrpcpb.MvccGetByStartTsRequest) (*kvrpcpb.MvccGetByStartTsResponse, error)
	BatchCommands(Tikv_BatchCommandsServer) error
}

func RegisterTikvServer(s *grpc.Server, srv TikvServer) {
	s.RegisterService(&_Tikv_serviceDesc, srv)
}

func _Tikv_KvGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvGet(ctx, req.(*kvrpcpb.GetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.ScanRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvScan(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvScan",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvScan(ctx, req.(*kvrpcpb.ScanRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvPrewrite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.PrewriteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvPrewrite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvPrewrite",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvPrewrite(ctx, req.(*kvrpcpb.PrewriteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvPessimisticLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.PessimisticLockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvPessimisticLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvPessimisticLock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvPessimisticLock(ctx, req.(*kvrpcpb.PessimisticLockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KVPessimisticRollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.PessimisticRollbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KVPessimisticRollback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KVPessimisticRollback",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KVPessimisticRollback(ctx, req.(*kvrpcpb.PessimisticRollbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvTxnHeartBeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.TxnHeartBeatRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvTxnHeartBeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvTxnHeartBeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvTxnHeartBeat(ctx, req.(*kvrpcpb.TxnHeartBeatRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvCheckTxnStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.CheckTxnStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvCheckTxnStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvCheckTxnStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvCheckTxnStatus(ctx, req.(*kvrpcpb.CheckTxnStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.CommitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvCommit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvCommit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvCommit(ctx, req.(*kvrpcpb.CommitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.ImportRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvImport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvImport",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvImport(ctx, req.(*kvrpcpb.ImportRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvCleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.CleanupRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvCleanup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvCleanup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvCleanup(ctx, req.(*kvrpcpb.CleanupRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvBatchGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.BatchGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvBatchGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvBatchGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvBatchGet(ctx, req.(*kvrpcpb.BatchGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvBatchRollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.BatchRollbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvBatchRollback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvBatchRollback",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvBatchRollback(ctx, req.(*kvrpcpb.BatchRollbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvScanLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.ScanLockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvScanLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvScanLock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvScanLock(ctx, req.(*kvrpcpb.ScanLockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvResolveLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.ResolveLockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvResolveLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvResolveLock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvResolveLock(ctx, req.(*kvrpcpb.ResolveLockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvGC_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.GCRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvGC(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvGC",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvGC(ctx, req.(*kvrpcpb.GCRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_KvDeleteRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.DeleteRangeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).KvDeleteRange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/KvDeleteRange",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).KvDeleteRange(ctx, req.(*kvrpcpb.DeleteRangeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawGet(ctx, req.(*kvrpcpb.RawGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawBatchGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawBatchGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawBatchGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawBatchGet",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawBatchGet(ctx, req.(*kvrpcpb.RawBatchGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawPutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawPut(ctx, req.(*kvrpcpb.RawPutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawBatchPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawBatchPutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawBatchPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawBatchPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawBatchPut(ctx, req.(*kvrpcpb.RawBatchPutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawDelete(ctx, req.(*kvrpcpb.RawDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawBatchDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawBatchDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawBatchDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawBatchDelete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawBatchDelete(ctx, req.(*kvrpcpb.RawBatchDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawScanRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawScan(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawScan",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawScan(ctx, req.(*kvrpcpb.RawScanRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawDeleteRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawDeleteRangeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawDeleteRange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawDeleteRange",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawDeleteRange(ctx, req.(*kvrpcpb.RawDeleteRangeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RawBatchScan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RawBatchScanRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RawBatchScan(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RawBatchScan",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RawBatchScan(ctx, req.(*kvrpcpb.RawBatchScanRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_UnsafeDestroyRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.UnsafeDestroyRangeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).UnsafeDestroyRange(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/UnsafeDestroyRange",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).UnsafeDestroyRange(ctx, req.(*kvrpcpb.UnsafeDestroyRangeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RegisterLockObserver_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RegisterLockObserverRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RegisterLockObserver(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RegisterLockObserver",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RegisterLockObserver(ctx, req.(*kvrpcpb.RegisterLockObserverRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_CheckLockObserver_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.CheckLockObserverRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).CheckLockObserver(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/CheckLockObserver",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).CheckLockObserver(ctx, req.(*kvrpcpb.CheckLockObserverRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_RemoveLockObserver_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.RemoveLockObserverRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).RemoveLockObserver(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/RemoveLockObserver",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).RemoveLockObserver(ctx, req.(*kvrpcpb.RemoveLockObserverRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_PhysicalScanLock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.PhysicalScanLockRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).PhysicalScanLock(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/PhysicalScanLock",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).PhysicalScanLock(ctx, req.(*kvrpcpb.PhysicalScanLockRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_Coprocessor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(coprocessor.Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).Coprocessor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/Coprocessor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).Coprocessor(ctx, req.(*coprocessor.Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_CoprocessorStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(coprocessor.Request)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TikvServer).CoprocessorStream(m, &tikvCoprocessorStreamServer{stream})
}

type Tikv_CoprocessorStreamServer interface {
	Send(*coprocessor.Response) error
	grpc.ServerStream
}

type tikvCoprocessorStreamServer struct {
	grpc.ServerStream
}

func (x *tikvCoprocessorStreamServer) Send(m *coprocessor.Response) error {
	return x.ServerStream.SendMsg(m)
}

func _Tikv_BatchCoprocessor_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(coprocessor.BatchRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(TikvServer).BatchCoprocessor(m, &tikvBatchCoprocessorServer{stream})
}

type Tikv_BatchCoprocessorServer interface {
	Send(*coprocessor.BatchResponse) error
	grpc.ServerStream
}

type tikvBatchCoprocessorServer struct {
	grpc.ServerStream
}

func (x *tikvBatchCoprocessorServer) Send(m *coprocessor.BatchResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Tikv_Raft_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(TikvServer).Raft(&tikvRaftServer{stream})
}

type Tikv_RaftServer interface {
	SendAndClose(*raft_serverpb.Done) error
	Recv() (*raft_serverpb.RaftMessage, error)
	grpc.ServerStream
}

type tikvRaftServer struct {
	grpc.ServerStream
}

func (x *tikvRaftServer) SendAndClose(m *raft_serverpb.Done) error {
	return x.ServerStream.SendMsg(m)
}

func (x *tikvRaftServer) Recv() (*raft_serverpb.RaftMessage, error) {
	m := new(raft_serverpb.RaftMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Tikv_BatchRaft_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(TikvServer).BatchRaft(&tikvBatchRaftServer{stream})
}

type Tikv_BatchRaftServer interface {
	SendAndClose(*raft_serverpb.Done) error
	Recv() (*BatchRaftMessage, error)
	grpc.ServerStream
}

type tikvBatchRaftServer struct {
	grpc.ServerStream
}

func (x *tikvBatchRaftServer) SendAndClose(m *raft_serverpb.Done) error {
	return x.ServerStream.SendMsg(m)
}

func (x *tikvBatchRaftServer) Recv() (*BatchRaftMessage, error) {
	m := new(BatchRaftMessage)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Tikv_Snapshot_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(TikvServer).Snapshot(&tikvSnapshotServer{stream})
}

type Tikv_SnapshotServer interface {
	SendAndClose(*raft_serverpb.Done) error
	Recv() (*raft_serverpb.SnapshotChunk, error)
	grpc.ServerStream
}

type tikvSnapshotServer struct {
	grpc.ServerStream
}

func (x *tikvSnapshotServer) SendAndClose(m *raft_serverpb.Done) error {
	return x.ServerStream.SendMsg(m)
}

func (x *tikvSnapshotServer) Recv() (*raft_serverpb.SnapshotChunk, error) {
	m := new(raft_serverpb.SnapshotChunk)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _Tikv_SplitRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.SplitRegionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).SplitRegion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/SplitRegion",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).SplitRegion(ctx, req.(*kvrpcpb.SplitRegionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_ReadIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.ReadIndexRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).ReadIndex(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/ReadIndex",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).ReadIndex(ctx, req.(*kvrpcpb.ReadIndexRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_MvccGetByKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.MvccGetByKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).MvccGetByKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/MvccGetByKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).MvccGetByKey(ctx, req.(*kvrpcpb.MvccGetByKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_MvccGetByStartTs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(kvrpcpb.MvccGetByStartTsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TikvServer).MvccGetByStartTs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/tikvpb.Tikv/MvccGetByStartTs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TikvServer).MvccGetByStartTs(ctx, req.(*kvrpcpb.MvccGetByStartTsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Tikv_BatchCommands_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(TikvServer).BatchCommands(&tikvBatchCommandsServer{stream})
}

type Tikv_BatchCommandsServer interface {
	Send(*BatchCommandsResponse) error
	Recv() (*BatchCommandsRequest, error)
	grpc.ServerStream
}

type tikvBatchCommandsServer struct {
	grpc.ServerStream
}

func (x *tikvBatchCommandsServer) Send(m *BatchCommandsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *tikvBatchCommandsServer) Recv() (*BatchCommandsRequest, error) {
	m := new(BatchCommandsRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _Tikv_serviceDesc = grpc.ServiceDesc{
	ServiceName: "tikvpb.Tikv",
	HandlerType: (*TikvServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "KvGet",
			Handler:    _Tikv_KvGet_Handler,
		},
		{
			MethodName: "KvScan",
			Handler:    _Tikv_KvScan_Handler,
		},
		{
			MethodName: "KvPrewrite",
			Handler:    _Tikv_KvPrewrite_Handler,
		},
		{
			MethodName: "KvPessimisticLock",
			Handler:    _Tikv_KvPessimisticLock_Handler,
		},
		{
			MethodName: "KVPessimisticRollback",
			Handler:    _Tikv_KVPessimisticRollback_Handler,
		},
		{
			MethodName: "KvTxnHeartBeat",
			Handler:    _Tikv_KvTxnHeartBeat_Handler,
		},
		{
			MethodName: "KvCheckTxnStatus",
			Handler:    _Tikv_KvCheckTxnStatus_Handler,
		},
		{
			MethodName: "KvCommit",
			Handler:    _Tikv_KvCommit_Handler,
		},
		{
			MethodName: "KvImport",
			Handler:    _Tikv_KvImport_Handler,
		},
		{
			MethodName: "KvCleanup",
			Handler:    _Tikv_KvCleanup_Handler,
		},
		{
			MethodName: "KvBatchGet",
			Handler:    _Tikv_KvBatchGet_Handler,
		},
		{
			MethodName: "KvBatchRollback",
			Handler:    _Tikv_KvBatchRollback_Handler,
		},
		{
			MethodName: "KvScanLock",
			Handler:    _Tikv_KvScanLock_Handler,
		},
		{
			MethodName: "KvResolveLock",
			Handler:    _Tikv_KvResolveLock_Handler,
		},
		{
			MethodName: "KvGC",
			Handler:    _Tikv_KvGC_Handler,
		},
		{
			MethodName: "KvDeleteRange",
			Handler:    _Tikv_KvDeleteRange_Handler,
		},
		{
			MethodName: "RawGet",
			Handler:    _Tikv_RawGet_Handler,
		},
		{
			MethodName: "RawBatchGet",
			Handler:    _Tikv_RawBatchGet_Handler,
		},
		{
			MethodName: "RawPut",
			Handler:    _Tikv_RawPut_Handler,
		},
		{
			MethodName: "RawBatchPut",
			Handler:    _Tikv_RawBatchPut_Handler,
		},
		{
			MethodName: "RawDelete",
			Handler:    _Tikv_RawDelete_Handler,
		},
		{
			MethodName: "RawBatchDelete",
			Handler:    _Tikv_RawBatchDelete_Handler,
		},
		{
			MethodName: "RawScan",
			Handler:    _Tikv_RawScan_Handler,
		},
		{
			MethodName: "RawDeleteRange",
			Handler:    _Tikv_RawDeleteRange_Handler,
		},
		{
			MethodName: "RawBatchScan",
			Handler:    _Tikv_RawBatchScan_Handler,
		},
		{
			MethodName: "UnsafeDestroyRange",
			Handler:    _Tikv_UnsafeDestroyRange_Handler,
		},
		{
			MethodName: "RegisterLockObserver",
			Handler:    _Tikv_RegisterLockObserver_Handler,
		},
		{
			MethodName: "CheckLockObserver",
			Handler:    _Tikv_CheckLockObserver_Handler,
		},
		{
			MethodName: "RemoveLockObserver",
			Handler:    _Tikv_RemoveLockObserver_Handler,
		},
		{
			MethodName: "PhysicalScanLock",
			Handler:    _Tikv_PhysicalScanLock_Handler,
		},
		{
			MethodName: "Coprocessor",
			Handler:    _Tikv_Coprocessor_Handler,
		},
		{
			MethodName: "SplitRegion",
			Handler:    _Tikv_SplitRegion_Handler,
		},
		{
			MethodName: "ReadIndex",
			Handler:    _Tikv_ReadIndex_Handler,
		},
		{
			MethodName: "MvccGetByKey",
			Handler:    _Tikv_MvccGetByKey_Handler,
		},
		{
			MethodName: "MvccGetByStartTs",
			Handler:    _Tikv_MvccGetByStartTs_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "CoprocessorStream",
			Handler:       _Tikv_CoprocessorStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "BatchCoprocessor",
			Handler:       _Tikv_BatchCoprocessor_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Raft",
			Handler:       _Tikv_Raft_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "BatchRaft",
			Handler:       _Tikv_BatchRaft_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "Snapshot",
			Handler:       _Tikv_Snapshot_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "BatchCommands",
			Handler:       _Tikv_BatchCommands_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "tikvpb.proto",
}

func (m *BatchCommandsRequest) 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 *BatchCommandsRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Requests) > 0 {
		for _, msg := range m.Requests {
			dAtA[i] = 0xa
			i++
			i = encodeVarintTikvpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.RequestIds) > 0 {
		dAtA2 := make([]byte, len(m.RequestIds)*10)
		var j1 int
		for _, num := range m.RequestIds {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(j1))
		i += copy(dAtA[i:], dAtA2[:j1])
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BatchCommandsRequest_Request) 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 *BatchCommandsRequest_Request) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Cmd != nil {
		nn3, err := m.Cmd.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn3
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BatchCommandsRequest_Request_Get) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Get != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Get.Size()))
		n4, err := m.Get.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_Scan) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Scan != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Scan.Size()))
		n5, err := m.Scan.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_Prewrite) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Prewrite != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Prewrite.Size()))
		n6, err := m.Prewrite.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_Commit) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Commit != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Commit.Size()))
		n7, err := m.Commit.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_Import) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Import != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Import.Size()))
		n8, err := m.Import.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_Cleanup) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Cleanup != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Cleanup.Size()))
		n9, err := m.Cleanup.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_BatchGet) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.BatchGet != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.BatchGet.Size()))
		n10, err := m.BatchGet.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_BatchRollback) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.BatchRollback != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.BatchRollback.Size()))
		n11, err := m.BatchRollback.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_ScanLock) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ScanLock != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.ScanLock.Size()))
		n12, err := m.ScanLock.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_ResolveLock) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ResolveLock != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.ResolveLock.Size()))
		n13, err := m.ResolveLock.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_GC) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.GC != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.GC.Size()))
		n14, err := m.GC.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_DeleteRange) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.DeleteRange != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.DeleteRange.Size()))
		n15, err := m.DeleteRange.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawGet) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawGet != nil {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawGet.Size()))
		n16, err := m.RawGet.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawBatchGet) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawBatchGet != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchGet.Size()))
		n17, err := m.RawBatchGet.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawPut) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawPut != nil {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawPut.Size()))
		n18, err := m.RawPut.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawBatchPut) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawBatchPut != nil {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchPut.Size()))
		n19, err := m.RawBatchPut.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawDelete) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawDelete != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawDelete.Size()))
		n20, err := m.RawDelete.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawBatchDelete) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawBatchDelete != nil {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchDelete.Size()))
		n21, err := m.RawBatchDelete.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawScan) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawScan != nil {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawScan.Size()))
		n22, err := m.RawScan.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n22
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawDeleteRange) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawDeleteRange != nil {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawDeleteRange.Size()))
		n23, err := m.RawDeleteRange.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n23
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_RawBatchScan) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawBatchScan != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchScan.Size()))
		n24, err := m.RawBatchScan.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n24
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_Coprocessor) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Coprocessor != nil {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Coprocessor.Size()))
		n25, err := m.Coprocessor.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n25
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_PessimisticLock) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.PessimisticLock != nil {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.PessimisticLock.Size()))
		n26, err := m.PessimisticLock.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_PessimisticRollback) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.PessimisticRollback != nil {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.PessimisticRollback.Size()))
		n27, err := m.PessimisticRollback.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n27
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_CheckTxnStatus) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.CheckTxnStatus != nil {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.CheckTxnStatus.Size()))
		n28, err := m.CheckTxnStatus.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n28
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_TxnHeartBeat) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.TxnHeartBeat != nil {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.TxnHeartBeat.Size()))
		n29, err := m.TxnHeartBeat.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	return i, nil
}
func (m *BatchCommandsRequest_Request_Empty) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Empty != nil {
		dAtA[i] = 0xfa
		i++
		dAtA[i] = 0xf
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Empty.Size()))
		n30, err := m.Empty.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	return i, nil
}
func (m *BatchCommandsResponse) 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 *BatchCommandsResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Responses) > 0 {
		for _, msg := range m.Responses {
			dAtA[i] = 0xa
			i++
			i = encodeVarintTikvpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.RequestIds) > 0 {
		dAtA32 := make([]byte, len(m.RequestIds)*10)
		var j31 int
		for _, num := range m.RequestIds {
			for num >= 1<<7 {
				dAtA32[j31] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j31++
			}
			dAtA32[j31] = uint8(num)
			j31++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(j31))
		i += copy(dAtA[i:], dAtA32[:j31])
	}
	if m.TransportLayerLoad != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.TransportLayerLoad))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BatchCommandsResponse_Response) 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 *BatchCommandsResponse_Response) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Cmd != nil {
		nn33, err := m.Cmd.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += nn33
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BatchCommandsResponse_Response_Get) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Get != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Get.Size()))
		n34, err := m.Get.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n34
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_Scan) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Scan != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Scan.Size()))
		n35, err := m.Scan.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n35
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_Prewrite) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Prewrite != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Prewrite.Size()))
		n36, err := m.Prewrite.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n36
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_Commit) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Commit != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Commit.Size()))
		n37, err := m.Commit.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n37
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_Import) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Import != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Import.Size()))
		n38, err := m.Import.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n38
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_Cleanup) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Cleanup != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Cleanup.Size()))
		n39, err := m.Cleanup.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n39
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_BatchGet) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.BatchGet != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.BatchGet.Size()))
		n40, err := m.BatchGet.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n40
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_BatchRollback) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.BatchRollback != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.BatchRollback.Size()))
		n41, err := m.BatchRollback.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n41
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_ScanLock) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ScanLock != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.ScanLock.Size()))
		n42, err := m.ScanLock.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n42
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_ResolveLock) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.ResolveLock != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.ResolveLock.Size()))
		n43, err := m.ResolveLock.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n43
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_GC) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.GC != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.GC.Size()))
		n44, err := m.GC.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n44
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_DeleteRange) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.DeleteRange != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.DeleteRange.Size()))
		n45, err := m.DeleteRange.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n45
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawGet) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawGet != nil {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawGet.Size()))
		n46, err := m.RawGet.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n46
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawBatchGet) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawBatchGet != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchGet.Size()))
		n47, err := m.RawBatchGet.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n47
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawPut) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawPut != nil {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawPut.Size()))
		n48, err := m.RawPut.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n48
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawBatchPut) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawBatchPut != nil {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchPut.Size()))
		n49, err := m.RawBatchPut.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n49
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawDelete) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawDelete != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawDelete.Size()))
		n50, err := m.RawDelete.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n50
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawBatchDelete) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawBatchDelete != nil {
		dAtA[i] = 0x92
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchDelete.Size()))
		n51, err := m.RawBatchDelete.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n51
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawScan) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawScan != nil {
		dAtA[i] = 0x9a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawScan.Size()))
		n52, err := m.RawScan.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n52
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawDeleteRange) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawDeleteRange != nil {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawDeleteRange.Size()))
		n53, err := m.RawDeleteRange.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n53
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_RawBatchScan) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.RawBatchScan != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.RawBatchScan.Size()))
		n54, err := m.RawBatchScan.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n54
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_Coprocessor) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Coprocessor != nil {
		dAtA[i] = 0xb2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Coprocessor.Size()))
		n55, err := m.Coprocessor.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n55
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_PessimisticLock) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.PessimisticLock != nil {
		dAtA[i] = 0xba
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.PessimisticLock.Size()))
		n56, err := m.PessimisticLock.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n56
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_PessimisticRollback) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.PessimisticRollback != nil {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.PessimisticRollback.Size()))
		n57, err := m.PessimisticRollback.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n57
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_CheckTxnStatus) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.CheckTxnStatus != nil {
		dAtA[i] = 0xca
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.CheckTxnStatus.Size()))
		n58, err := m.CheckTxnStatus.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n58
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_TxnHeartBeat) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.TxnHeartBeat != nil {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.TxnHeartBeat.Size()))
		n59, err := m.TxnHeartBeat.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n59
	}
	return i, nil
}
func (m *BatchCommandsResponse_Response_Empty) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Empty != nil {
		dAtA[i] = 0xfa
		i++
		dAtA[i] = 0xf
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.Empty.Size()))
		n60, err := m.Empty.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n60
	}
	return i, nil
}
func (m *BatchRaftMessage) 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 *BatchRaftMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Msgs) > 0 {
		for _, msg := range m.Msgs {
			dAtA[i] = 0xa
			i++
			i = encodeVarintTikvpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BatchCommandsEmptyRequest) 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 *BatchCommandsEmptyRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TestId != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.TestId))
	}
	if m.DelayTime != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintTikvpb(dAtA, i, uint64(m.DelayTime))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func encodeVarintTikvpb(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 *BatchCommandsRequest) Size() (n int) {
	var l int
	_ = l
	if len(m.Requests) > 0 {
		for _, e := range m.Requests {
			l = e.Size()
			n += 1 + l + sovTikvpb(uint64(l))
		}
	}
	if len(m.RequestIds) > 0 {
		l = 0
		for _, e := range m.RequestIds {
			l += sovTikvpb(uint64(e))
		}
		n += 1 + sovTikvpb(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsRequest_Request) Size() (n int) {
	var l int
	_ = l
	if m.Cmd != nil {
		n += m.Cmd.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsRequest_Request_Get) Size() (n int) {
	var l int
	_ = l
	if m.Get != nil {
		l = m.Get.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Scan) Size() (n int) {
	var l int
	_ = l
	if m.Scan != nil {
		l = m.Scan.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Prewrite) Size() (n int) {
	var l int
	_ = l
	if m.Prewrite != nil {
		l = m.Prewrite.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Commit) Size() (n int) {
	var l int
	_ = l
	if m.Commit != nil {
		l = m.Commit.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Import) Size() (n int) {
	var l int
	_ = l
	if m.Import != nil {
		l = m.Import.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Cleanup) Size() (n int) {
	var l int
	_ = l
	if m.Cleanup != nil {
		l = m.Cleanup.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_BatchGet) Size() (n int) {
	var l int
	_ = l
	if m.BatchGet != nil {
		l = m.BatchGet.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_BatchRollback) Size() (n int) {
	var l int
	_ = l
	if m.BatchRollback != nil {
		l = m.BatchRollback.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_ScanLock) Size() (n int) {
	var l int
	_ = l
	if m.ScanLock != nil {
		l = m.ScanLock.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_ResolveLock) Size() (n int) {
	var l int
	_ = l
	if m.ResolveLock != nil {
		l = m.ResolveLock.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_GC) Size() (n int) {
	var l int
	_ = l
	if m.GC != nil {
		l = m.GC.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_DeleteRange) Size() (n int) {
	var l int
	_ = l
	if m.DeleteRange != nil {
		l = m.DeleteRange.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawGet) Size() (n int) {
	var l int
	_ = l
	if m.RawGet != nil {
		l = m.RawGet.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawBatchGet) Size() (n int) {
	var l int
	_ = l
	if m.RawBatchGet != nil {
		l = m.RawBatchGet.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawPut) Size() (n int) {
	var l int
	_ = l
	if m.RawPut != nil {
		l = m.RawPut.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawBatchPut) Size() (n int) {
	var l int
	_ = l
	if m.RawBatchPut != nil {
		l = m.RawBatchPut.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawDelete) Size() (n int) {
	var l int
	_ = l
	if m.RawDelete != nil {
		l = m.RawDelete.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawBatchDelete) Size() (n int) {
	var l int
	_ = l
	if m.RawBatchDelete != nil {
		l = m.RawBatchDelete.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawScan) Size() (n int) {
	var l int
	_ = l
	if m.RawScan != nil {
		l = m.RawScan.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawDeleteRange) Size() (n int) {
	var l int
	_ = l
	if m.RawDeleteRange != nil {
		l = m.RawDeleteRange.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_RawBatchScan) Size() (n int) {
	var l int
	_ = l
	if m.RawBatchScan != nil {
		l = m.RawBatchScan.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Coprocessor) Size() (n int) {
	var l int
	_ = l
	if m.Coprocessor != nil {
		l = m.Coprocessor.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_PessimisticLock) Size() (n int) {
	var l int
	_ = l
	if m.PessimisticLock != nil {
		l = m.PessimisticLock.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_PessimisticRollback) Size() (n int) {
	var l int
	_ = l
	if m.PessimisticRollback != nil {
		l = m.PessimisticRollback.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_CheckTxnStatus) Size() (n int) {
	var l int
	_ = l
	if m.CheckTxnStatus != nil {
		l = m.CheckTxnStatus.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_TxnHeartBeat) Size() (n int) {
	var l int
	_ = l
	if m.TxnHeartBeat != nil {
		l = m.TxnHeartBeat.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsRequest_Request_Empty) Size() (n int) {
	var l int
	_ = l
	if m.Empty != nil {
		l = m.Empty.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse) Size() (n int) {
	var l int
	_ = l
	if len(m.Responses) > 0 {
		for _, e := range m.Responses {
			l = e.Size()
			n += 1 + l + sovTikvpb(uint64(l))
		}
	}
	if len(m.RequestIds) > 0 {
		l = 0
		for _, e := range m.RequestIds {
			l += sovTikvpb(uint64(e))
		}
		n += 1 + sovTikvpb(uint64(l)) + l
	}
	if m.TransportLayerLoad != 0 {
		n += 1 + sovTikvpb(uint64(m.TransportLayerLoad))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsResponse_Response) Size() (n int) {
	var l int
	_ = l
	if m.Cmd != nil {
		n += m.Cmd.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsResponse_Response_Get) Size() (n int) {
	var l int
	_ = l
	if m.Get != nil {
		l = m.Get.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Scan) Size() (n int) {
	var l int
	_ = l
	if m.Scan != nil {
		l = m.Scan.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Prewrite) Size() (n int) {
	var l int
	_ = l
	if m.Prewrite != nil {
		l = m.Prewrite.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Commit) Size() (n int) {
	var l int
	_ = l
	if m.Commit != nil {
		l = m.Commit.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Import) Size() (n int) {
	var l int
	_ = l
	if m.Import != nil {
		l = m.Import.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Cleanup) Size() (n int) {
	var l int
	_ = l
	if m.Cleanup != nil {
		l = m.Cleanup.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_BatchGet) Size() (n int) {
	var l int
	_ = l
	if m.BatchGet != nil {
		l = m.BatchGet.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_BatchRollback) Size() (n int) {
	var l int
	_ = l
	if m.BatchRollback != nil {
		l = m.BatchRollback.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_ScanLock) Size() (n int) {
	var l int
	_ = l
	if m.ScanLock != nil {
		l = m.ScanLock.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_ResolveLock) Size() (n int) {
	var l int
	_ = l
	if m.ResolveLock != nil {
		l = m.ResolveLock.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_GC) Size() (n int) {
	var l int
	_ = l
	if m.GC != nil {
		l = m.GC.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_DeleteRange) Size() (n int) {
	var l int
	_ = l
	if m.DeleteRange != nil {
		l = m.DeleteRange.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawGet) Size() (n int) {
	var l int
	_ = l
	if m.RawGet != nil {
		l = m.RawGet.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawBatchGet) Size() (n int) {
	var l int
	_ = l
	if m.RawBatchGet != nil {
		l = m.RawBatchGet.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawPut) Size() (n int) {
	var l int
	_ = l
	if m.RawPut != nil {
		l = m.RawPut.Size()
		n += 1 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawBatchPut) Size() (n int) {
	var l int
	_ = l
	if m.RawBatchPut != nil {
		l = m.RawBatchPut.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawDelete) Size() (n int) {
	var l int
	_ = l
	if m.RawDelete != nil {
		l = m.RawDelete.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawBatchDelete) Size() (n int) {
	var l int
	_ = l
	if m.RawBatchDelete != nil {
		l = m.RawBatchDelete.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawScan) Size() (n int) {
	var l int
	_ = l
	if m.RawScan != nil {
		l = m.RawScan.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawDeleteRange) Size() (n int) {
	var l int
	_ = l
	if m.RawDeleteRange != nil {
		l = m.RawDeleteRange.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_RawBatchScan) Size() (n int) {
	var l int
	_ = l
	if m.RawBatchScan != nil {
		l = m.RawBatchScan.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Coprocessor) Size() (n int) {
	var l int
	_ = l
	if m.Coprocessor != nil {
		l = m.Coprocessor.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_PessimisticLock) Size() (n int) {
	var l int
	_ = l
	if m.PessimisticLock != nil {
		l = m.PessimisticLock.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_PessimisticRollback) Size() (n int) {
	var l int
	_ = l
	if m.PessimisticRollback != nil {
		l = m.PessimisticRollback.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_CheckTxnStatus) Size() (n int) {
	var l int
	_ = l
	if m.CheckTxnStatus != nil {
		l = m.CheckTxnStatus.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_TxnHeartBeat) Size() (n int) {
	var l int
	_ = l
	if m.TxnHeartBeat != nil {
		l = m.TxnHeartBeat.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchCommandsResponse_Response_Empty) Size() (n int) {
	var l int
	_ = l
	if m.Empty != nil {
		l = m.Empty.Size()
		n += 2 + l + sovTikvpb(uint64(l))
	}
	return n
}
func (m *BatchRaftMessage) Size() (n int) {
	var l int
	_ = l
	if len(m.Msgs) > 0 {
		for _, e := range m.Msgs {
			l = e.Size()
			n += 1 + l + sovTikvpb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsEmptyRequest) Size() (n int) {
	var l int
	_ = l
	if m.TestId != 0 {
		n += 1 + sovTikvpb(uint64(m.TestId))
	}
	if m.DelayTime != 0 {
		n += 1 + sovTikvpb(uint64(m.DelayTime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BatchCommandsEmptyResponse) Size() (n int) {
	var l int
	_ = l
	if m.TestId != 0 {
		n += 1 + sovTikvpb(uint64(m.TestId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovTikvpb(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozTikvpb(x uint64) (n int) {
	return sovTikvpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *BatchCommandsRequest) 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 ErrIntOverflowTikvpb
			}
			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: BatchCommandsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchCommandsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requests = append(m.Requests, &BatchCommandsRequest_Request{})
			if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTikvpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RequestIds = append(m.RequestIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTikvpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTikvpb
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTikvpb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RequestIds = append(m.RequestIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestIds", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTikvpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTikvpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BatchCommandsRequest_Request) 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 ErrIntOverflowTikvpb
			}
			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: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.GetRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Get{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.ScanRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Scan{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prewrite", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.PrewriteRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Prewrite{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.CommitRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Commit{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Import", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.ImportRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Import{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cleanup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.CleanupRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Cleanup{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchGet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.BatchGetRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_BatchGet{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchRollback", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.BatchRollbackRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_BatchRollback{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScanLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.ScanLockRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_ScanLock{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolveLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.ResolveLockRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_ResolveLock{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GC", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.GCRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_GC{v}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeleteRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.DeleteRangeRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_DeleteRange{v}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawGet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawGetRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawGet{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBatchGet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawBatchGetRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawBatchGet{v}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawPut", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawPutRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawPut{v}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBatchPut", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawBatchPutRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawBatchPut{v}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawDeleteRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawDelete{v}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBatchDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawBatchDeleteRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawBatchDelete{v}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawScan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawScanRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawScan{v}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawDeleteRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawDeleteRangeRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawDeleteRange{v}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBatchScan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawBatchScanRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_RawBatchScan{v}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coprocessor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &coprocessor.Request{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Coprocessor{v}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PessimisticLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.PessimisticLockRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_PessimisticLock{v}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PessimisticRollback", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.PessimisticRollbackRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_PessimisticRollback{v}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckTxnStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.CheckTxnStatusRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_CheckTxnStatus{v}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnHeartBeat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.TxnHeartBeatRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_TxnHeartBeat{v}
			iNdEx = postIndex
		case 255:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Empty", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BatchCommandsEmptyRequest{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsRequest_Request_Empty{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTikvpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTikvpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BatchCommandsResponse) 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 ErrIntOverflowTikvpb
			}
			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: BatchCommandsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BatchCommandsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Responses = append(m.Responses, &BatchCommandsResponse_Response{})
			if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTikvpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.RequestIds = append(m.RequestIds, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTikvpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTikvpb
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTikvpb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.RequestIds = append(m.RequestIds, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestIds", wireType)
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransportLayerLoad", wireType)
			}
			m.TransportLayerLoad = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TransportLayerLoad |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTikvpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTikvpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BatchCommandsResponse_Response) 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 ErrIntOverflowTikvpb
			}
			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: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.GetResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Get{v}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.ScanResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Scan{v}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prewrite", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.PrewriteResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Prewrite{v}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.CommitResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Commit{v}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Import", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.ImportResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Import{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cleanup", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.CleanupResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Cleanup{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchGet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.BatchGetResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_BatchGet{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchRollback", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.BatchRollbackResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_BatchRollback{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScanLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.ScanLockResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_ScanLock{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResolveLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.ResolveLockResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_ResolveLock{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GC", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.GCResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_GC{v}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeleteRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.DeleteRangeResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_DeleteRange{v}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawGet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawGetResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawGet{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBatchGet", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawBatchGetResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawBatchGet{v}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawPut", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawPutResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawPut{v}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBatchPut", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawBatchPutResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawBatchPut{v}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawDeleteResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawDelete{v}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBatchDelete", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawBatchDeleteResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawBatchDelete{v}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawScan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawScanResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawScan{v}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawDeleteRange", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawDeleteRangeResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawDeleteRange{v}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawBatchScan", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.RawBatchScanResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_RawBatchScan{v}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coprocessor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &coprocessor.Response{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Coprocessor{v}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PessimisticLock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.PessimisticLockResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_PessimisticLock{v}
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PessimisticRollback", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.PessimisticRollbackResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_PessimisticRollback{v}
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckTxnStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.CheckTxnStatusResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_CheckTxnStatus{v}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxnHeartBeat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &kvrpcpb.TxnHeartBeatResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_TxnHeartBeat{v}
			iNdEx = postIndex
		case 255:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Empty", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTikvpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTikvpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &BatchCommandsEmptyResponse{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Cmd = &BatchCommandsResponse_Response_Empty{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTikvpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTikvpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

func init() { proto.RegisterFile("tikvpb.proto", fileDescriptor_tikvpb_90bf9910f92409ea) }

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