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

package debugpb

import (
	"fmt"
	"io"
	"math"

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

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

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

	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 DB int32

const (
	DB_INVALID DB = 0
	DB_KV      DB = 1
	DB_RAFT    DB = 2
)

var DB_name = map[int32]string{
	0: "INVALID",
	1: "KV",
	2: "RAFT",
}
var DB_value = map[string]int32{
	"INVALID": 0,
	"KV":      1,
	"RAFT":    2,
}

func (x DB) String() string {
	return proto.EnumName(DB_name, int32(x))
}
func (DB) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_debugpb_b0ba9b224e8564d2, []int{0}
}

type MODULE int32

const (
	MODULE_UNUSED      MODULE = 0
	MODULE_KVDB        MODULE = 1
	MODULE_RAFTDB      MODULE = 2
	MODULE_READPOOL    MODULE = 3
	MODULE_SERVER      MODULE = 4
	MODULE_STORAGE     MODULE = 5
	MODULE_PD          MODULE = 6
	MODULE_METRIC      MODULE = 7
	MODULE_COPROCESSOR MODULE = 8
	MODULE_SECURITY    MODULE = 9
	MODULE_IMPORT      MODULE = 10
)

var MODULE_name = map[int32]string{
	0:  "UNUSED",
	1:  "KVDB",
	2:  "RAFTDB",
	3:  "READPOOL",
	4:  "SERVER",
	5:  "STORAGE",
	6:  "PD",
	7:  "METRIC",
	8:  "COPROCESSOR",
	9:  "SECURITY",
	10: "IMPORT",
}
var MODULE_value = map[string]int32{
	"UNUSED":      0,
	"KVDB":        1,
	"RAFTDB":      2,
	"READPOOL":    3,
	"SERVER":      4,
	"STORAGE":     5,
	"PD":          6,
	"METRIC":      7,
	"COPROCESSOR": 8,
	"SECURITY":    9,
	"IMPORT":      10,
}

func (x MODULE) String() string {
	return proto.EnumName(MODULE_name, int32(x))
}
func (MODULE) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_debugpb_b0ba9b224e8564d2, []int{1}
}

type BottommostLevelCompaction int32

const (
	// Skip bottommost level compaction
	BottommostLevelCompaction_Skip BottommostLevelCompaction = 0
	// Force bottommost level compaction
	BottommostLevelCompaction_Force BottommostLevelCompaction = 1
	// Compact bottommost level if there is a compaction filter.
	BottommostLevelCompaction_IfHaveCompactionFilter BottommostLevelCompaction = 2
)

var BottommostLevelCompaction_name = map[int32]string{
	0: "Skip",
	1: "Force",
	2: "IfHaveCompactionFilter",
}
var BottommostLevelCompaction_value = map[string]int32{
	"Skip":                   0,
	"Force":                  1,
	"IfHaveCompactionFilter": 2,
}

func (x BottommostLevelCompaction) String() string {
	return proto.EnumName(BottommostLevelCompaction_name, int32(x))
}
func (BottommostLevelCompaction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_debugpb_b0ba9b224e8564d2, []int{2}
}

type GetRequest struct {
	Db                   DB       `protobuf:"varint,1,opt,name=db,proto3,enum=debugpb.DB" json:"db,omitempty"`
	Cf                   string   `protobuf:"bytes,2,opt,name=cf,proto3" json:"cf,omitempty"`
	Key                  []byte   `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetRequest proto.InternalMessageInfo

func (m *GetRequest) GetDb() DB {
	if m != nil {
		return m.Db
	}
	return DB_INVALID
}

func (m *GetRequest) GetCf() string {
	if m != nil {
		return m.Cf
	}
	return ""
}

func (m *GetRequest) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

type GetResponse struct {
	Value                []byte   `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetResponse proto.InternalMessageInfo

func (m *GetResponse) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type RaftLogRequest struct {
	RegionId             uint64   `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
	LogIndex             uint64   `protobuf:"varint,2,opt,name=log_index,json=logIndex,proto3" json:"log_index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RaftLogRequest proto.InternalMessageInfo

func (m *RaftLogRequest) GetRegionId() uint64 {
	if m != nil {
		return m.RegionId
	}
	return 0
}

func (m *RaftLogRequest) GetLogIndex() uint64 {
	if m != nil {
		return m.LogIndex
	}
	return 0
}

type RaftLogResponse struct {
	Entry                *eraftpb.Entry `protobuf:"bytes,1,opt,name=entry" json:"entry,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_RaftLogResponse proto.InternalMessageInfo

func (m *RaftLogResponse) GetEntry() *eraftpb.Entry {
	if m != nil {
		return m.Entry
	}
	return nil
}

type RegionInfoRequest struct {
	RegionId             uint64   `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RegionInfoRequest proto.InternalMessageInfo

func (m *RegionInfoRequest) GetRegionId() uint64 {
	if m != nil {
		return m.RegionId
	}
	return 0
}

type RegionInfoResponse struct {
	RaftLocalState       *raft_serverpb.RaftLocalState   `protobuf:"bytes,1,opt,name=raft_local_state,json=raftLocalState" json:"raft_local_state,omitempty"`
	RaftApplyState       *raft_serverpb.RaftApplyState   `protobuf:"bytes,2,opt,name=raft_apply_state,json=raftApplyState" json:"raft_apply_state,omitempty"`
	RegionLocalState     *raft_serverpb.RegionLocalState `protobuf:"bytes,3,opt,name=region_local_state,json=regionLocalState" json:"region_local_state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

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

var xxx_messageInfo_RegionInfoResponse proto.InternalMessageInfo

func (m *RegionInfoResponse) GetRaftLocalState() *raft_serverpb.RaftLocalState {
	if m != nil {
		return m.RaftLocalState
	}
	return nil
}

func (m *RegionInfoResponse) GetRaftApplyState() *raft_serverpb.RaftApplyState {
	if m != nil {
		return m.RaftApplyState
	}
	return nil
}

func (m *RegionInfoResponse) GetRegionLocalState() *raft_serverpb.RegionLocalState {
	if m != nil {
		return m.RegionLocalState
	}
	return nil
}

type RegionSizeRequest struct {
	RegionId             uint64   `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
	Cfs                  []string `protobuf:"bytes,2,rep,name=cfs" json:"cfs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RegionSizeRequest proto.InternalMessageInfo

func (m *RegionSizeRequest) GetRegionId() uint64 {
	if m != nil {
		return m.RegionId
	}
	return 0
}

func (m *RegionSizeRequest) GetCfs() []string {
	if m != nil {
		return m.Cfs
	}
	return nil
}

type RegionSizeResponse struct {
	Entries              []*RegionSizeResponse_Entry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_RegionSizeResponse proto.InternalMessageInfo

func (m *RegionSizeResponse) GetEntries() []*RegionSizeResponse_Entry {
	if m != nil {
		return m.Entries
	}
	return nil
}

type RegionSizeResponse_Entry struct {
	Cf                   string   `protobuf:"bytes,1,opt,name=cf,proto3" json:"cf,omitempty"`
	Size_                uint64   `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RegionSizeResponse_Entry proto.InternalMessageInfo

func (m *RegionSizeResponse_Entry) GetCf() string {
	if m != nil {
		return m.Cf
	}
	return ""
}

func (m *RegionSizeResponse_Entry) GetSize_() uint64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

type ScanMvccRequest struct {
	FromKey              []byte   `protobuf:"bytes,1,opt,name=from_key,json=fromKey,proto3" json:"from_key,omitempty"`
	ToKey                []byte   `protobuf:"bytes,2,opt,name=to_key,json=toKey,proto3" json:"to_key,omitempty"`
	Limit                uint64   `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ScanMvccRequest proto.InternalMessageInfo

func (m *ScanMvccRequest) GetFromKey() []byte {
	if m != nil {
		return m.FromKey
	}
	return nil
}

func (m *ScanMvccRequest) GetToKey() []byte {
	if m != nil {
		return m.ToKey
	}
	return nil
}

func (m *ScanMvccRequest) GetLimit() uint64 {
	if m != nil {
		return m.Limit
	}
	return 0
}

type ScanMvccResponse struct {
	Key                  []byte            `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Info                 *kvrpcpb.MvccInfo `protobuf:"bytes,2,opt,name=info" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_ScanMvccResponse proto.InternalMessageInfo

func (m *ScanMvccResponse) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *ScanMvccResponse) GetInfo() *kvrpcpb.MvccInfo {
	if m != nil {
		return m.Info
	}
	return nil
}

type CompactRequest struct {
	Db                        DB                        `protobuf:"varint,1,opt,name=db,proto3,enum=debugpb.DB" json:"db,omitempty"`
	Cf                        string                    `protobuf:"bytes,2,opt,name=cf,proto3" json:"cf,omitempty"`
	FromKey                   []byte                    `protobuf:"bytes,3,opt,name=from_key,json=fromKey,proto3" json:"from_key,omitempty"`
	ToKey                     []byte                    `protobuf:"bytes,4,opt,name=to_key,json=toKey,proto3" json:"to_key,omitempty"`
	Threads                   uint32                    `protobuf:"varint,5,opt,name=threads,proto3" json:"threads,omitempty"`
	BottommostLevelCompaction BottommostLevelCompaction `protobuf:"varint,6,opt,name=bottommost_level_compaction,json=bottommostLevelCompaction,proto3,enum=debugpb.BottommostLevelCompaction" json:"bottommost_level_compaction,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}                  `json:"-"`
	XXX_unrecognized          []byte                    `json:"-"`
	XXX_sizecache             int32                     `json:"-"`
}

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

var xxx_messageInfo_CompactRequest proto.InternalMessageInfo

func (m *CompactRequest) GetDb() DB {
	if m != nil {
		return m.Db
	}
	return DB_INVALID
}

func (m *CompactRequest) GetCf() string {
	if m != nil {
		return m.Cf
	}
	return ""
}

func (m *CompactRequest) GetFromKey() []byte {
	if m != nil {
		return m.FromKey
	}
	return nil
}

func (m *CompactRequest) GetToKey() []byte {
	if m != nil {
		return m.ToKey
	}
	return nil
}

func (m *CompactRequest) GetThreads() uint32 {
	if m != nil {
		return m.Threads
	}
	return 0
}

func (m *CompactRequest) GetBottommostLevelCompaction() BottommostLevelCompaction {
	if m != nil {
		return m.BottommostLevelCompaction
	}
	return BottommostLevelCompaction_Skip
}

type CompactResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CompactResponse proto.InternalMessageInfo

type InjectFailPointRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Actions              string   `protobuf:"bytes,2,opt,name=actions,proto3" json:"actions,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_InjectFailPointRequest proto.InternalMessageInfo

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

func (m *InjectFailPointRequest) GetActions() string {
	if m != nil {
		return m.Actions
	}
	return ""
}

type InjectFailPointResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_InjectFailPointResponse proto.InternalMessageInfo

type RecoverFailPointRequest struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RecoverFailPointRequest proto.InternalMessageInfo

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

type RecoverFailPointResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RecoverFailPointResponse proto.InternalMessageInfo

type ListFailPointsRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListFailPointsRequest proto.InternalMessageInfo

type ListFailPointsResponse struct {
	Entries              []*ListFailPointsResponse_Entry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

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

var xxx_messageInfo_ListFailPointsResponse proto.InternalMessageInfo

func (m *ListFailPointsResponse) GetEntries() []*ListFailPointsResponse_Entry {
	if m != nil {
		return m.Entries
	}
	return nil
}

type ListFailPointsResponse_Entry struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Actions              string   `protobuf:"bytes,2,opt,name=actions,proto3" json:"actions,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ListFailPointsResponse_Entry proto.InternalMessageInfo

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

func (m *ListFailPointsResponse_Entry) GetActions() string {
	if m != nil {
		return m.Actions
	}
	return ""
}

type GetMetricsRequest struct {
	All                  bool     `protobuf:"varint,1,opt,name=all,proto3" json:"all,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetMetricsRequest proto.InternalMessageInfo

func (m *GetMetricsRequest) GetAll() bool {
	if m != nil {
		return m.All
	}
	return false
}

type GetMetricsResponse struct {
	Prometheus           string   `protobuf:"bytes,1,opt,name=prometheus,proto3" json:"prometheus,omitempty"`
	RocksdbKv            string   `protobuf:"bytes,2,opt,name=rocksdb_kv,json=rocksdbKv,proto3" json:"rocksdb_kv,omitempty"`
	RocksdbRaft          string   `protobuf:"bytes,3,opt,name=rocksdb_raft,json=rocksdbRaft,proto3" json:"rocksdb_raft,omitempty"`
	Jemalloc             string   `protobuf:"bytes,4,opt,name=jemalloc,proto3" json:"jemalloc,omitempty"`
	StoreId              uint64   `protobuf:"varint,5,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetMetricsResponse proto.InternalMessageInfo

func (m *GetMetricsResponse) GetPrometheus() string {
	if m != nil {
		return m.Prometheus
	}
	return ""
}

func (m *GetMetricsResponse) GetRocksdbKv() string {
	if m != nil {
		return m.RocksdbKv
	}
	return ""
}

func (m *GetMetricsResponse) GetRocksdbRaft() string {
	if m != nil {
		return m.RocksdbRaft
	}
	return ""
}

func (m *GetMetricsResponse) GetJemalloc() string {
	if m != nil {
		return m.Jemalloc
	}
	return ""
}

func (m *GetMetricsResponse) GetStoreId() uint64 {
	if m != nil {
		return m.StoreId
	}
	return 0
}

type RegionConsistencyCheckRequest struct {
	RegionId             uint64   `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RegionConsistencyCheckRequest proto.InternalMessageInfo

func (m *RegionConsistencyCheckRequest) GetRegionId() uint64 {
	if m != nil {
		return m.RegionId
	}
	return 0
}

type RegionConsistencyCheckResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RegionConsistencyCheckResponse proto.InternalMessageInfo

type ModifyTikvConfigRequest struct {
	Module               MODULE   `protobuf:"varint,1,opt,name=module,proto3,enum=debugpb.MODULE" json:"module,omitempty"`
	ConfigName           string   `protobuf:"bytes,2,opt,name=config_name,json=configName,proto3" json:"config_name,omitempty"`
	ConfigValue          string   `protobuf:"bytes,3,opt,name=config_value,json=configValue,proto3" json:"config_value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModifyTikvConfigRequest proto.InternalMessageInfo

func (m *ModifyTikvConfigRequest) GetModule() MODULE {
	if m != nil {
		return m.Module
	}
	return MODULE_UNUSED
}

func (m *ModifyTikvConfigRequest) GetConfigName() string {
	if m != nil {
		return m.ConfigName
	}
	return ""
}

func (m *ModifyTikvConfigRequest) GetConfigValue() string {
	if m != nil {
		return m.ConfigValue
	}
	return ""
}

type ModifyTikvConfigResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ModifyTikvConfigResponse proto.InternalMessageInfo

type Property struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Property proto.InternalMessageInfo

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

func (m *Property) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type GetRegionPropertiesRequest struct {
	RegionId             uint64   `protobuf:"varint,1,opt,name=region_id,json=regionId,proto3" json:"region_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetRegionPropertiesRequest proto.InternalMessageInfo

func (m *GetRegionPropertiesRequest) GetRegionId() uint64 {
	if m != nil {
		return m.RegionId
	}
	return 0
}

type GetRegionPropertiesResponse struct {
	Props                []*Property `protobuf:"bytes,1,rep,name=props" json:"props,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_GetRegionPropertiesResponse proto.InternalMessageInfo

func (m *GetRegionPropertiesResponse) GetProps() []*Property {
	if m != nil {
		return m.Props
	}
	return nil
}

type GetStoreInfoRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetStoreInfoRequest proto.InternalMessageInfo

type GetStoreInfoResponse struct {
	StoreId              uint64   `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3" json:"store_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetStoreInfoResponse proto.InternalMessageInfo

func (m *GetStoreInfoResponse) GetStoreId() uint64 {
	if m != nil {
		return m.StoreId
	}
	return 0
}

type GetClusterInfoRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetClusterInfoRequest proto.InternalMessageInfo

type GetClusterInfoResponse struct {
	ClusterId            uint64   `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetClusterInfoResponse proto.InternalMessageInfo

func (m *GetClusterInfoResponse) GetClusterId() uint64 {
	if m != nil {
		return m.ClusterId
	}
	return 0
}

func init() {
	proto.RegisterType((*GetRequest)(nil), "debugpb.GetRequest")
	proto.RegisterType((*GetResponse)(nil), "debugpb.GetResponse")
	proto.RegisterType((*RaftLogRequest)(nil), "debugpb.RaftLogRequest")
	proto.RegisterType((*RaftLogResponse)(nil), "debugpb.RaftLogResponse")
	proto.RegisterType((*RegionInfoRequest)(nil), "debugpb.RegionInfoRequest")
	proto.RegisterType((*RegionInfoResponse)(nil), "debugpb.RegionInfoResponse")
	proto.RegisterType((*RegionSizeRequest)(nil), "debugpb.RegionSizeRequest")
	proto.RegisterType((*RegionSizeResponse)(nil), "debugpb.RegionSizeResponse")
	proto.RegisterType((*RegionSizeResponse_Entry)(nil), "debugpb.RegionSizeResponse.Entry")
	proto.RegisterType((*ScanMvccRequest)(nil), "debugpb.ScanMvccRequest")
	proto.RegisterType((*ScanMvccResponse)(nil), "debugpb.ScanMvccResponse")
	proto.RegisterType((*CompactRequest)(nil), "debugpb.CompactRequest")
	proto.RegisterType((*CompactResponse)(nil), "debugpb.CompactResponse")
	proto.RegisterType((*InjectFailPointRequest)(nil), "debugpb.InjectFailPointRequest")
	proto.RegisterType((*InjectFailPointResponse)(nil), "debugpb.InjectFailPointResponse")
	proto.RegisterType((*RecoverFailPointRequest)(nil), "debugpb.RecoverFailPointRequest")
	proto.RegisterType((*RecoverFailPointResponse)(nil), "debugpb.RecoverFailPointResponse")
	proto.RegisterType((*ListFailPointsRequest)(nil), "debugpb.ListFailPointsRequest")
	proto.RegisterType((*ListFailPointsResponse)(nil), "debugpb.ListFailPointsResponse")
	proto.RegisterType((*ListFailPointsResponse_Entry)(nil), "debugpb.ListFailPointsResponse.Entry")
	proto.RegisterType((*GetMetricsRequest)(nil), "debugpb.GetMetricsRequest")
	proto.RegisterType((*GetMetricsResponse)(nil), "debugpb.GetMetricsResponse")
	proto.RegisterType((*RegionConsistencyCheckRequest)(nil), "debugpb.RegionConsistencyCheckRequest")
	proto.RegisterType((*RegionConsistencyCheckResponse)(nil), "debugpb.RegionConsistencyCheckResponse")
	proto.RegisterType((*ModifyTikvConfigRequest)(nil), "debugpb.ModifyTikvConfigRequest")
	proto.RegisterType((*ModifyTikvConfigResponse)(nil), "debugpb.ModifyTikvConfigResponse")
	proto.RegisterType((*Property)(nil), "debugpb.Property")
	proto.RegisterType((*GetRegionPropertiesRequest)(nil), "debugpb.GetRegionPropertiesRequest")
	proto.RegisterType((*GetRegionPropertiesResponse)(nil), "debugpb.GetRegionPropertiesResponse")
	proto.RegisterType((*GetStoreInfoRequest)(nil), "debugpb.GetStoreInfoRequest")
	proto.RegisterType((*GetStoreInfoResponse)(nil), "debugpb.GetStoreInfoResponse")
	proto.RegisterType((*GetClusterInfoRequest)(nil), "debugpb.GetClusterInfoRequest")
	proto.RegisterType((*GetClusterInfoResponse)(nil), "debugpb.GetClusterInfoResponse")
	proto.RegisterEnum("debugpb.DB", DB_name, DB_value)
	proto.RegisterEnum("debugpb.MODULE", MODULE_name, MODULE_value)
	proto.RegisterEnum("debugpb.BottommostLevelCompaction", BottommostLevelCompaction_name, BottommostLevelCompaction_value)
}

// 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 Debug service

type DebugClient interface {
	// Read a value arbitrarily for a key.
	// Note: Server uses key directly w/o any encoding.
	Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error)
	// Read raft info.
	RaftLog(ctx context.Context, in *RaftLogRequest, opts ...grpc.CallOption) (*RaftLogResponse, error)
	RegionInfo(ctx context.Context, in *RegionInfoRequest, opts ...grpc.CallOption) (*RegionInfoResponse, error)
	// Calculate size of a region.
	// Note: DO NOT CALL IT IN PRODUCTION, it's really expensive.
	RegionSize(ctx context.Context, in *RegionSizeRequest, opts ...grpc.CallOption) (*RegionSizeResponse, error)
	// Scan a specific range.
	// Note: DO NOT CALL IT IN PRODUCTION, it's really expensive.
	//       Server uses keys directly w/o any encoding.
	ScanMvcc(ctx context.Context, in *ScanMvccRequest, opts ...grpc.CallOption) (Debug_ScanMvccClient, error)
	// Compact a column family in a specified range.
	// Note: Server uses keys directly w/o any encoding.
	Compact(ctx context.Context, in *CompactRequest, opts ...grpc.CallOption) (*CompactResponse, error)
	// Inject a fail point. Currently, it's only used in tests.
	// Note: DO NOT CALL IT IN PRODUCTION.
	InjectFailPoint(ctx context.Context, in *InjectFailPointRequest, opts ...grpc.CallOption) (*InjectFailPointResponse, error)
	// Recover from a fail point.
	RecoverFailPoint(ctx context.Context, in *RecoverFailPointRequest, opts ...grpc.CallOption) (*RecoverFailPointResponse, error)
	// List all fail points.
	ListFailPoints(ctx context.Context, in *ListFailPointsRequest, opts ...grpc.CallOption) (*ListFailPointsResponse, error)
	// Get Metrics
	GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error)
	// Do a consistent check for a region.
	CheckRegionConsistency(ctx context.Context, in *RegionConsistencyCheckRequest, opts ...grpc.CallOption) (*RegionConsistencyCheckResponse, error)
	// dynamically modify tikv's config
	ModifyTikvConfig(ctx context.Context, in *ModifyTikvConfigRequest, opts ...grpc.CallOption) (*ModifyTikvConfigResponse, error)
	// Get region properties
	GetRegionProperties(ctx context.Context, in *GetRegionPropertiesRequest, opts ...grpc.CallOption) (*GetRegionPropertiesResponse, error)
	// Get store ID
	GetStoreInfo(ctx context.Context, in *GetStoreInfoRequest, opts ...grpc.CallOption) (*GetStoreInfoResponse, error)
	// Get cluster ID
	GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error)
}

type debugClient struct {
	cc *grpc.ClientConn
}

func NewDebugClient(cc *grpc.ClientConn) DebugClient {
	return &debugClient{cc}
}

func (c *debugClient) Get(ctx context.Context, in *GetRequest, opts ...grpc.CallOption) (*GetResponse, error) {
	out := new(GetResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) RaftLog(ctx context.Context, in *RaftLogRequest, opts ...grpc.CallOption) (*RaftLogResponse, error) {
	out := new(RaftLogResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/RaftLog", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) RegionInfo(ctx context.Context, in *RegionInfoRequest, opts ...grpc.CallOption) (*RegionInfoResponse, error) {
	out := new(RegionInfoResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/RegionInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) RegionSize(ctx context.Context, in *RegionSizeRequest, opts ...grpc.CallOption) (*RegionSizeResponse, error) {
	out := new(RegionSizeResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/RegionSize", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) ScanMvcc(ctx context.Context, in *ScanMvccRequest, opts ...grpc.CallOption) (Debug_ScanMvccClient, error) {
	stream, err := c.cc.NewStream(ctx, &_Debug_serviceDesc.Streams[0], "/debugpb.Debug/ScanMvcc", opts...)
	if err != nil {
		return nil, err
	}
	x := &debugScanMvccClient{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 Debug_ScanMvccClient interface {
	Recv() (*ScanMvccResponse, error)
	grpc.ClientStream
}

type debugScanMvccClient struct {
	grpc.ClientStream
}

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

func (c *debugClient) Compact(ctx context.Context, in *CompactRequest, opts ...grpc.CallOption) (*CompactResponse, error) {
	out := new(CompactResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/Compact", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) InjectFailPoint(ctx context.Context, in *InjectFailPointRequest, opts ...grpc.CallOption) (*InjectFailPointResponse, error) {
	out := new(InjectFailPointResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/InjectFailPoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) RecoverFailPoint(ctx context.Context, in *RecoverFailPointRequest, opts ...grpc.CallOption) (*RecoverFailPointResponse, error) {
	out := new(RecoverFailPointResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/RecoverFailPoint", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) ListFailPoints(ctx context.Context, in *ListFailPointsRequest, opts ...grpc.CallOption) (*ListFailPointsResponse, error) {
	out := new(ListFailPointsResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/ListFailPoints", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) GetMetrics(ctx context.Context, in *GetMetricsRequest, opts ...grpc.CallOption) (*GetMetricsResponse, error) {
	out := new(GetMetricsResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/GetMetrics", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) CheckRegionConsistency(ctx context.Context, in *RegionConsistencyCheckRequest, opts ...grpc.CallOption) (*RegionConsistencyCheckResponse, error) {
	out := new(RegionConsistencyCheckResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/CheckRegionConsistency", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) ModifyTikvConfig(ctx context.Context, in *ModifyTikvConfigRequest, opts ...grpc.CallOption) (*ModifyTikvConfigResponse, error) {
	out := new(ModifyTikvConfigResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/ModifyTikvConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) GetRegionProperties(ctx context.Context, in *GetRegionPropertiesRequest, opts ...grpc.CallOption) (*GetRegionPropertiesResponse, error) {
	out := new(GetRegionPropertiesResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/GetRegionProperties", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) GetStoreInfo(ctx context.Context, in *GetStoreInfoRequest, opts ...grpc.CallOption) (*GetStoreInfoResponse, error) {
	out := new(GetStoreInfoResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/GetStoreInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *debugClient) GetClusterInfo(ctx context.Context, in *GetClusterInfoRequest, opts ...grpc.CallOption) (*GetClusterInfoResponse, error) {
	out := new(GetClusterInfoResponse)
	err := c.cc.Invoke(ctx, "/debugpb.Debug/GetClusterInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Debug service

type DebugServer interface {
	// Read a value arbitrarily for a key.
	// Note: Server uses key directly w/o any encoding.
	Get(context.Context, *GetRequest) (*GetResponse, error)
	// Read raft info.
	RaftLog(context.Context, *RaftLogRequest) (*RaftLogResponse, error)
	RegionInfo(context.Context, *RegionInfoRequest) (*RegionInfoResponse, error)
	// Calculate size of a region.
	// Note: DO NOT CALL IT IN PRODUCTION, it's really expensive.
	RegionSize(context.Context, *RegionSizeRequest) (*RegionSizeResponse, error)
	// Scan a specific range.
	// Note: DO NOT CALL IT IN PRODUCTION, it's really expensive.
	//       Server uses keys directly w/o any encoding.
	ScanMvcc(*ScanMvccRequest, Debug_ScanMvccServer) error
	// Compact a column family in a specified range.
	// Note: Server uses keys directly w/o any encoding.
	Compact(context.Context, *CompactRequest) (*CompactResponse, error)
	// Inject a fail point. Currently, it's only used in tests.
	// Note: DO NOT CALL IT IN PRODUCTION.
	InjectFailPoint(context.Context, *InjectFailPointRequest) (*InjectFailPointResponse, error)
	// Recover from a fail point.
	RecoverFailPoint(context.Context, *RecoverFailPointRequest) (*RecoverFailPointResponse, error)
	// List all fail points.
	ListFailPoints(context.Context, *ListFailPointsRequest) (*ListFailPointsResponse, error)
	// Get Metrics
	GetMetrics(context.Context, *GetMetricsRequest) (*GetMetricsResponse, error)
	// Do a consistent check for a region.
	CheckRegionConsistency(context.Context, *RegionConsistencyCheckRequest) (*RegionConsistencyCheckResponse, error)
	// dynamically modify tikv's config
	ModifyTikvConfig(context.Context, *ModifyTikvConfigRequest) (*ModifyTikvConfigResponse, error)
	// Get region properties
	GetRegionProperties(context.Context, *GetRegionPropertiesRequest) (*GetRegionPropertiesResponse, error)
	// Get store ID
	GetStoreInfo(context.Context, *GetStoreInfoRequest) (*GetStoreInfoResponse, error)
	// Get cluster ID
	GetClusterInfo(context.Context, *GetClusterInfoRequest) (*GetClusterInfoResponse, error)
}

func RegisterDebugServer(s *grpc.Server, srv DebugServer) {
	s.RegisterService(&_Debug_serviceDesc, srv)
}

func _Debug_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).Get(ctx, req.(*GetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_RaftLog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RaftLogRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).RaftLog(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/RaftLog",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).RaftLog(ctx, req.(*RaftLogRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_RegionInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).RegionInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/RegionInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).RegionInfo(ctx, req.(*RegionInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_RegionSize_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionSizeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).RegionSize(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/RegionSize",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).RegionSize(ctx, req.(*RegionSizeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_ScanMvcc_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ScanMvccRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DebugServer).ScanMvcc(m, &debugScanMvccServer{stream})
}

type Debug_ScanMvccServer interface {
	Send(*ScanMvccResponse) error
	grpc.ServerStream
}

type debugScanMvccServer struct {
	grpc.ServerStream
}

func (x *debugScanMvccServer) Send(m *ScanMvccResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Debug_Compact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CompactRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).Compact(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/Compact",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).Compact(ctx, req.(*CompactRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_InjectFailPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InjectFailPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).InjectFailPoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/InjectFailPoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).InjectFailPoint(ctx, req.(*InjectFailPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_RecoverFailPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RecoverFailPointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).RecoverFailPoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/RecoverFailPoint",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).RecoverFailPoint(ctx, req.(*RecoverFailPointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_ListFailPoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListFailPointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).ListFailPoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/ListFailPoints",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).ListFailPoints(ctx, req.(*ListFailPointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_GetMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMetricsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).GetMetrics(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/GetMetrics",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).GetMetrics(ctx, req.(*GetMetricsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_CheckRegionConsistency_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegionConsistencyCheckRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).CheckRegionConsistency(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/CheckRegionConsistency",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).CheckRegionConsistency(ctx, req.(*RegionConsistencyCheckRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_ModifyTikvConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ModifyTikvConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).ModifyTikvConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/ModifyTikvConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).ModifyTikvConfig(ctx, req.(*ModifyTikvConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_GetRegionProperties_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRegionPropertiesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).GetRegionProperties(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/GetRegionProperties",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).GetRegionProperties(ctx, req.(*GetRegionPropertiesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_GetStoreInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetStoreInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).GetStoreInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/GetStoreInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).GetStoreInfo(ctx, req.(*GetStoreInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Debug_GetClusterInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DebugServer).GetClusterInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/debugpb.Debug/GetClusterInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DebugServer).GetClusterInfo(ctx, req.(*GetClusterInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Debug_serviceDesc = grpc.ServiceDesc{
	ServiceName: "debugpb.Debug",
	HandlerType: (*DebugServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Get",
			Handler:    _Debug_Get_Handler,
		},
		{
			MethodName: "RaftLog",
			Handler:    _Debug_RaftLog_Handler,
		},
		{
			MethodName: "RegionInfo",
			Handler:    _Debug_RegionInfo_Handler,
		},
		{
			MethodName: "RegionSize",
			Handler:    _Debug_RegionSize_Handler,
		},
		{
			MethodName: "Compact",
			Handler:    _Debug_Compact_Handler,
		},
		{
			MethodName: "InjectFailPoint",
			Handler:    _Debug_InjectFailPoint_Handler,
		},
		{
			MethodName: "RecoverFailPoint",
			Handler:    _Debug_RecoverFailPoint_Handler,
		},
		{
			MethodName: "ListFailPoints",
			Handler:    _Debug_ListFailPoints_Handler,
		},
		{
			MethodName: "GetMetrics",
			Handler:    _Debug_GetMetrics_Handler,
		},
		{
			MethodName: "CheckRegionConsistency",
			Handler:    _Debug_CheckRegionConsistency_Handler,
		},
		{
			MethodName: "ModifyTikvConfig",
			Handler:    _Debug_ModifyTikvConfig_Handler,
		},
		{
			MethodName: "GetRegionProperties",
			Handler:    _Debug_GetRegionProperties_Handler,
		},
		{
			MethodName: "GetStoreInfo",
			Handler:    _Debug_GetStoreInfo_Handler,
		},
		{
			MethodName: "GetClusterInfo",
			Handler:    _Debug_GetClusterInfo_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ScanMvcc",
			Handler:       _Debug_ScanMvcc_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "debugpb.proto",
}

func (m *GetRequest) 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 *GetRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Db != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.Db))
	}
	if len(m.Cf) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Cf)))
		i += copy(dAtA[i:], m.Cf)
	}
	if len(m.Key) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

func (m *RaftLogResponse) 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 *RaftLogResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Entry != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.Entry.Size()))
		n1, err := m.Entry.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *RegionInfoResponse) 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 *RegionInfoResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.RaftLocalState != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.RaftLocalState.Size()))
		n2, err := m.RaftLocalState.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.RaftApplyState != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.RaftApplyState.Size()))
		n3, err := m.RaftApplyState.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.RegionLocalState != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.RegionLocalState.Size()))
		n4, err := m.RegionLocalState.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *RegionSizeResponse) 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 *RegionSizeResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, msg := range m.Entries {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDebugpb(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 *RegionSizeResponse_Entry) 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 *RegionSizeResponse_Entry) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Cf) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Cf)))
		i += copy(dAtA[i:], m.Cf)
	}
	if m.Size_ != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.Size_))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *ScanMvccRequest) 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 *ScanMvccRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.FromKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.FromKey)))
		i += copy(dAtA[i:], m.FromKey)
	}
	if len(m.ToKey) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.ToKey)))
		i += copy(dAtA[i:], m.ToKey)
	}
	if m.Limit != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *CompactRequest) 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 *CompactRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Db != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.Db))
	}
	if len(m.Cf) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Cf)))
		i += copy(dAtA[i:], m.Cf)
	}
	if len(m.FromKey) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.FromKey)))
		i += copy(dAtA[i:], m.FromKey)
	}
	if len(m.ToKey) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.ToKey)))
		i += copy(dAtA[i:], m.ToKey)
	}
	if m.Threads != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.Threads))
	}
	if m.BottommostLevelCompaction != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.BottommostLevelCompaction))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *InjectFailPointRequest) 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 *InjectFailPointRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Actions) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Actions)))
		i += copy(dAtA[i:], m.Actions)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

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

func (m *ListFailPointsResponse) 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 *ListFailPointsResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, msg := range m.Entries {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDebugpb(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 *ListFailPointsResponse_Entry) 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 *ListFailPointsResponse_Entry) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Actions) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Actions)))
		i += copy(dAtA[i:], m.Actions)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *GetMetricsResponse) 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 *GetMetricsResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Prometheus) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Prometheus)))
		i += copy(dAtA[i:], m.Prometheus)
	}
	if len(m.RocksdbKv) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.RocksdbKv)))
		i += copy(dAtA[i:], m.RocksdbKv)
	}
	if len(m.RocksdbRaft) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.RocksdbRaft)))
		i += copy(dAtA[i:], m.RocksdbRaft)
	}
	if len(m.Jemalloc) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Jemalloc)))
		i += copy(dAtA[i:], m.Jemalloc)
	}
	if m.StoreId != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.StoreId))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

func (m *ModifyTikvConfigRequest) 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 *ModifyTikvConfigRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Module != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(m.Module))
	}
	if len(m.ConfigName) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.ConfigName)))
		i += copy(dAtA[i:], m.ConfigName)
	}
	if len(m.ConfigValue) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.ConfigValue)))
		i += copy(dAtA[i:], m.ConfigValue)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *Property) 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 *Property) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Name)))
		i += copy(dAtA[i:], m.Name)
	}
	if len(m.Value) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDebugpb(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *GetRegionPropertiesResponse) 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 *GetRegionPropertiesResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Props) > 0 {
		for _, msg := range m.Props {
			dAtA[i] = 0xa
			i++
			i = encodeVarintDebugpb(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 *GetStoreInfoRequest) 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 *GetStoreInfoRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

func encodeVarintDebugpb(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 *GetRequest) Size() (n int) {
	var l int
	_ = l
	if m.Db != 0 {
		n += 1 + sovDebugpb(uint64(m.Db))
	}
	l = len(m.Cf)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetResponse) Size() (n int) {
	var l int
	_ = l
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftLogRequest) Size() (n int) {
	var l int
	_ = l
	if m.RegionId != 0 {
		n += 1 + sovDebugpb(uint64(m.RegionId))
	}
	if m.LogIndex != 0 {
		n += 1 + sovDebugpb(uint64(m.LogIndex))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftLogResponse) Size() (n int) {
	var l int
	_ = l
	if m.Entry != nil {
		l = m.Entry.Size()
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *RegionInfoResponse) Size() (n int) {
	var l int
	_ = l
	if m.RaftLocalState != nil {
		l = m.RaftLocalState.Size()
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.RaftApplyState != nil {
		l = m.RaftApplyState.Size()
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.RegionLocalState != nil {
		l = m.RegionLocalState.Size()
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RegionSizeRequest) Size() (n int) {
	var l int
	_ = l
	if m.RegionId != 0 {
		n += 1 + sovDebugpb(uint64(m.RegionId))
	}
	if len(m.Cfs) > 0 {
		for _, s := range m.Cfs {
			l = len(s)
			n += 1 + l + sovDebugpb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RegionSizeResponse) Size() (n int) {
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovDebugpb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RegionSizeResponse_Entry) Size() (n int) {
	var l int
	_ = l
	l = len(m.Cf)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.Size_ != 0 {
		n += 1 + sovDebugpb(uint64(m.Size_))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ScanMvccRequest) Size() (n int) {
	var l int
	_ = l
	l = len(m.FromKey)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.ToKey)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.Limit != 0 {
		n += 1 + sovDebugpb(uint64(m.Limit))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ScanMvccResponse) Size() (n int) {
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.Info != nil {
		l = m.Info.Size()
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CompactRequest) Size() (n int) {
	var l int
	_ = l
	if m.Db != 0 {
		n += 1 + sovDebugpb(uint64(m.Db))
	}
	l = len(m.Cf)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.FromKey)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.ToKey)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.Threads != 0 {
		n += 1 + sovDebugpb(uint64(m.Threads))
	}
	if m.BottommostLevelCompaction != 0 {
		n += 1 + sovDebugpb(uint64(m.BottommostLevelCompaction))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *InjectFailPointRequest) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.Actions)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *RecoverFailPointRequest) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *ListFailPointsResponse) Size() (n int) {
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovDebugpb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ListFailPointsResponse_Entry) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.Actions)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *GetMetricsResponse) Size() (n int) {
	var l int
	_ = l
	l = len(m.Prometheus)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.RocksdbKv)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.RocksdbRaft)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.Jemalloc)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.StoreId != 0 {
		n += 1 + sovDebugpb(uint64(m.StoreId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *ModifyTikvConfigRequest) Size() (n int) {
	var l int
	_ = l
	if m.Module != 0 {
		n += 1 + sovDebugpb(uint64(m.Module))
	}
	l = len(m.ConfigName)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.ConfigValue)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Property) Size() (n int) {
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovDebugpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *GetRegionPropertiesResponse) Size() (n int) {
	var l int
	_ = l
	if len(m.Props) > 0 {
		for _, e := range m.Props {
			l = e.Size()
			n += 1 + l + sovDebugpb(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

func sovDebugpb(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozDebugpb(x uint64) (n int) {
	return sovDebugpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GetRequest) 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 ErrIntOverflowDebugpb
			}
			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: GetRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType)
			}
			m.Db = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Db |= (DB(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cf = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
			if m.Key == nil {
				m.Key = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetResponse) 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 ErrIntOverflowDebugpb
			}
			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: GetResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RaftLogRequest) 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 ErrIntOverflowDebugpb
			}
			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: RaftLogRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftLogRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			m.RegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegionId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogIndex", wireType)
			}
			m.LogIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogIndex |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RaftLogResponse) 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 ErrIntOverflowDebugpb
			}
			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: RaftLogResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftLogResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Entry == nil {
				m.Entry = &eraftpb.Entry{}
			}
			if err := m.Entry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RegionInfoRequest) 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 ErrIntOverflowDebugpb
			}
			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: RegionInfoRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegionInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			m.RegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegionId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RegionInfoResponse) 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 ErrIntOverflowDebugpb
			}
			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: RegionInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegionInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaftLocalState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RaftLocalState == nil {
				m.RaftLocalState = &raft_serverpb.RaftLocalState{}
			}
			if err := m.RaftLocalState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaftApplyState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RaftApplyState == nil {
				m.RaftApplyState = &raft_serverpb.RaftApplyState{}
			}
			if err := m.RaftApplyState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionLocalState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RegionLocalState == nil {
				m.RegionLocalState = &raft_serverpb.RegionLocalState{}
			}
			if err := m.RegionLocalState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RegionSizeRequest) 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 ErrIntOverflowDebugpb
			}
			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: RegionSizeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegionSizeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			m.RegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegionId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cfs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cfs = append(m.Cfs, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RegionSizeResponse) 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 ErrIntOverflowDebugpb
			}
			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: RegionSizeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegionSizeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, &RegionSizeResponse_Entry{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RegionSizeResponse_Entry) 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 ErrIntOverflowDebugpb
			}
			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: Entry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cf = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *ScanMvccRequest) 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 ErrIntOverflowDebugpb
			}
			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: ScanMvccRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScanMvccRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromKey = append(m.FromKey[:0], dAtA[iNdEx:postIndex]...)
			if m.FromKey == nil {
				m.FromKey = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToKey = append(m.ToKey[:0], dAtA[iNdEx:postIndex]...)
			if m.ToKey == nil {
				m.ToKey = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *ScanMvccResponse) 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 ErrIntOverflowDebugpb
			}
			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: ScanMvccResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScanMvccResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
			if m.Key == nil {
				m.Key = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Info == nil {
				m.Info = &kvrpcpb.MvccInfo{}
			}
			if err := m.Info.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *CompactRequest) 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 ErrIntOverflowDebugpb
			}
			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: CompactRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompactRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Db", wireType)
			}
			m.Db = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Db |= (DB(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cf", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cf = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromKey = append(m.FromKey[:0], dAtA[iNdEx:postIndex]...)
			if m.FromKey == nil {
				m.FromKey = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToKey = append(m.ToKey[:0], dAtA[iNdEx:postIndex]...)
			if m.ToKey == nil {
				m.ToKey = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Threads", wireType)
			}
			m.Threads = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Threads |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BottommostLevelCompaction", wireType)
			}
			m.BottommostLevelCompaction = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BottommostLevelCompaction |= (BottommostLevelCompaction(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *CompactResponse) 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 ErrIntOverflowDebugpb
			}
			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: CompactResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompactResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *InjectFailPointRequest) 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 ErrIntOverflowDebugpb
			}
			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: InjectFailPointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InjectFailPointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Actions = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *InjectFailPointResponse) 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 ErrIntOverflowDebugpb
			}
			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: InjectFailPointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InjectFailPointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RecoverFailPointRequest) 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 ErrIntOverflowDebugpb
			}
			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: RecoverFailPointRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecoverFailPointRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RecoverFailPointResponse) 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 ErrIntOverflowDebugpb
			}
			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: RecoverFailPointResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecoverFailPointResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *ListFailPointsRequest) 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 ErrIntOverflowDebugpb
			}
			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: ListFailPointsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListFailPointsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *ListFailPointsResponse) 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 ErrIntOverflowDebugpb
			}
			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: ListFailPointsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListFailPointsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, &ListFailPointsResponse_Entry{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *ListFailPointsResponse_Entry) 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 ErrIntOverflowDebugpb
			}
			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: Entry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Actions = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetMetricsRequest) 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 ErrIntOverflowDebugpb
			}
			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: GetMetricsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetMetricsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field All", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.All = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetMetricsResponse) 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 ErrIntOverflowDebugpb
			}
			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: GetMetricsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetMetricsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prometheus", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Prometheus = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RocksdbKv", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RocksdbKv = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RocksdbRaft", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RocksdbRaft = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Jemalloc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Jemalloc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType)
			}
			m.StoreId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoreId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RegionConsistencyCheckRequest) 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 ErrIntOverflowDebugpb
			}
			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: RegionConsistencyCheckRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegionConsistencyCheckRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			m.RegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegionId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *RegionConsistencyCheckResponse) 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 ErrIntOverflowDebugpb
			}
			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: RegionConsistencyCheckResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RegionConsistencyCheckResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *ModifyTikvConfigRequest) 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 ErrIntOverflowDebugpb
			}
			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: ModifyTikvConfigRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModifyTikvConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Module", wireType)
			}
			m.Module = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Module |= (MODULE(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfigName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfigValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *ModifyTikvConfigResponse) 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 ErrIntOverflowDebugpb
			}
			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: ModifyTikvConfigResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ModifyTikvConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *Property) 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 ErrIntOverflowDebugpb
			}
			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: Property: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Property: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetRegionPropertiesRequest) 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 ErrIntOverflowDebugpb
			}
			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: GetRegionPropertiesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRegionPropertiesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RegionId", wireType)
			}
			m.RegionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RegionId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetRegionPropertiesResponse) 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 ErrIntOverflowDebugpb
			}
			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: GetRegionPropertiesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetRegionPropertiesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Props", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDebugpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Props = append(m.Props, &Property{})
			if err := m.Props[len(m.Props)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetStoreInfoRequest) 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 ErrIntOverflowDebugpb
			}
			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: GetStoreInfoRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetStoreInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetStoreInfoResponse) 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 ErrIntOverflowDebugpb
			}
			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: GetStoreInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetStoreInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreId", wireType)
			}
			m.StoreId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StoreId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetClusterInfoRequest) 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 ErrIntOverflowDebugpb
			}
			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: GetClusterInfoRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetClusterInfoRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 *GetClusterInfoResponse) 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 ErrIntOverflowDebugpb
			}
			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: GetClusterInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetClusterInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			m.ClusterId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDebugpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ClusterId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDebugpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDebugpb
			}
			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 skipDebugpb(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, ErrIntOverflowDebugpb
			}
			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, ErrIntOverflowDebugpb
				}
				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, ErrIntOverflowDebugpb
				}
				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, ErrInvalidLengthDebugpb
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowDebugpb
					}
					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 := skipDebugpb(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 (
	ErrInvalidLengthDebugpb = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDebugpb   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("debugpb.proto", fileDescriptor_debugpb_b0ba9b224e8564d2) }

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