raftcmdpb.pb.go

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

package raftcmdpb

import (
	encoding_binary "encoding/binary"
	"fmt"
	"io"
	"math"

	errorpb "github.com/201341/elasticell/pkg/pb/errorpb"

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

	math_bits "math/bits"

	metapb "github.com/201341/elasticell/pkg/pb/metapb"
	pdpb "github.com/201341/elasticell/pkg/pb/pdpb"
)

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

type CMDType int32

const (
	Invalid   CMDType = 0
	RaftError CMDType = 1
	Snap      CMDType = 2
	// common
	Ping CMDType = 100
	Del  CMDType = 101
	// kv
	Set      CMDType = 200
	Get      CMDType = 201
	MSet     CMDType = 202
	MGet     CMDType = 203
	Incrby   CMDType = 204
	Decrby   CMDType = 205
	GetSet   CMDType = 206
	Append   CMDType = 207
	Setnx    CMDType = 208
	StrLen   CMDType = 209
	Incr     CMDType = 210
	Decr     CMDType = 211
	SetRange CMDType = 212
	MSetNX   CMDType = 213
	// Hash
	HSet     CMDType = 300
	HGet     CMDType = 301
	HDel     CMDType = 302
	HExists  CMDType = 303
	HKeys    CMDType = 304
	HVals    CMDType = 305
	HGetAll  CMDType = 306
	HLen     CMDType = 307
	HMGet    CMDType = 308
	HMSet    CMDType = 309
	HSetNX   CMDType = 310
	HStrLen  CMDType = 311
	HIncrBy  CMDType = 312
	HScanGet CMDType = 313
	// lists
	LIndex    CMDType = 400
	LInsert   CMDType = 401
	LLEN      CMDType = 402
	LPop      CMDType = 403
	LPush     CMDType = 404
	LPushX    CMDType = 405
	LRange    CMDType = 406
	LRem      CMDType = 407
	LSet      CMDType = 408
	LTrim     CMDType = 409
	RPop      CMDType = 410
	RPopLPush CMDType = 411
	RPush     CMDType = 412
	RPushX    CMDType = 413
	// sets
	SAdd      CMDType = 500
	SCard     CMDType = 501
	SRem      CMDType = 502
	SMembers  CMDType = 503
	SIsMember CMDType = 504
	SPop      CMDType = 505
	// zsets
	ZAdd             CMDType = 600
	ZCard            CMDType = 601
	ZCount           CMDType = 602
	ZIncrBy          CMDType = 603
	ZLexCount        CMDType = 604
	ZRange           CMDType = 605
	ZRangeByLex      CMDType = 606
	ZRangeByScore    CMDType = 607
	ZRank            CMDType = 608
	ZRem             CMDType = 609
	ZRemRangeByLex   CMDType = 611
	ZRemRangeByRank  CMDType = 612
	ZRemRangeByScore CMDType = 613
	ZScore           CMDType = 614
	// lock
	Lock     CMDType = 700
	Unlock   CMDType = 701
	Lockable CMDType = 702
	// bitmap
	BMCreate   CMDType = 800
	BMAdd      CMDType = 801
	BMRemove   CMDType = 802
	BMClear    CMDType = 803
	BMContains CMDType = 804
	BMDel      CMDType = 805
	BMCount    CMDType = 806
	BMRange    CMDType = 807
)

var CMDType_name = map[int32]string{
	0:   "Invalid",
	1:   "RaftError",
	2:   "Snap",
	100: "Ping",
	101: "Del",
	200: "Set",
	201: "Get",
	202: "MSet",
	203: "MGet",
	204: "Incrby",
	205: "Decrby",
	206: "GetSet",
	207: "Append",
	208: "Setnx",
	209: "StrLen",
	210: "Incr",
	211: "Decr",
	212: "SetRange",
	213: "MSetNX",
	300: "HSet",
	301: "HGet",
	302: "HDel",
	303: "HExists",
	304: "HKeys",
	305: "HVals",
	306: "HGetAll",
	307: "HLen",
	308: "HMGet",
	309: "HMSet",
	310: "HSetNX",
	311: "HStrLen",
	312: "HIncrBy",
	313: "HScanGet",
	400: "LIndex",
	401: "LInsert",
	402: "LLEN",
	403: "LPop",
	404: "LPush",
	405: "LPushX",
	406: "LRange",
	407: "LRem",
	408: "LSet",
	409: "LTrim",
	410: "RPop",
	411: "RPopLPush",
	412: "RPush",
	413: "RPushX",
	500: "SAdd",
	501: "SCard",
	502: "SRem",
	503: "SMembers",
	504: "SIsMember",
	505: "SPop",
	600: "ZAdd",
	601: "ZCard",
	602: "ZCount",
	603: "ZIncrBy",
	604: "ZLexCount",
	605: "ZRange",
	606: "ZRangeByLex",
	607: "ZRangeByScore",
	608: "ZRank",
	609: "ZRem",
	611: "ZRemRangeByLex",
	612: "ZRemRangeByRank",
	613: "ZRemRangeByScore",
	614: "ZScore",
	700: "Lock",
	701: "Unlock",
	702: "Lockable",
	800: "BMCreate",
	801: "BMAdd",
	802: "BMRemove",
	803: "BMClear",
	804: "BMContains",
	805: "BMDel",
	806: "BMCount",
	807: "BMRange",
}

var CMDType_value = map[string]int32{
	"Invalid":          0,
	"RaftError":        1,
	"Snap":             2,
	"Ping":             100,
	"Del":              101,
	"Set":              200,
	"Get":              201,
	"MSet":             202,
	"MGet":             203,
	"Incrby":           204,
	"Decrby":           205,
	"GetSet":           206,
	"Append":           207,
	"Setnx":            208,
	"StrLen":           209,
	"Incr":             210,
	"Decr":             211,
	"SetRange":         212,
	"MSetNX":           213,
	"HSet":             300,
	"HGet":             301,
	"HDel":             302,
	"HExists":          303,
	"HKeys":            304,
	"HVals":            305,
	"HGetAll":          306,
	"HLen":             307,
	"HMGet":            308,
	"HMSet":            309,
	"HSetNX":           310,
	"HStrLen":          311,
	"HIncrBy":          312,
	"HScanGet":         313,
	"LIndex":           400,
	"LInsert":          401,
	"LLEN":             402,
	"LPop":             403,
	"LPush":            404,
	"LPushX":           405,
	"LRange":           406,
	"LRem":             407,
	"LSet":             408,
	"LTrim":            409,
	"RPop":             410,
	"RPopLPush":        411,
	"RPush":            412,
	"RPushX":           413,
	"SAdd":             500,
	"SCard":            501,
	"SRem":             502,
	"SMembers":         503,
	"SIsMember":        504,
	"SPop":             505,
	"ZAdd":             600,
	"ZCard":            601,
	"ZCount":           602,
	"ZIncrBy":          603,
	"ZLexCount":        604,
	"ZRange":           605,
	"ZRangeByLex":      606,
	"ZRangeByScore":    607,
	"ZRank":            608,
	"ZRem":             609,
	"ZRemRangeByLex":   611,
	"ZRemRangeByRank":  612,
	"ZRemRangeByScore": 613,
	"ZScore":           614,
	"Lock":             700,
	"Unlock":           701,
	"Lockable":         702,
	"BMCreate":         800,
	"BMAdd":            801,
	"BMRemove":         802,
	"BMClear":          803,
	"BMContains":       804,
	"BMDel":            805,
	"BMCount":          806,
	"BMRange":          807,
}

func (x CMDType) Enum() *CMDType {
	p := new(CMDType)
	*p = x
	return p
}

func (x CMDType) String() string {
	return proto.EnumName(CMDType_name, int32(x))
}

func (x *CMDType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(CMDType_value, data, "CMDType")
	if err != nil {
		return err
	}
	*x = CMDType(value)
	return nil
}

func (CMDType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{0}
}

type AdminCmdType int32

const (
	InvalidAdmin   AdminCmdType = 0
	ChangePeer     AdminCmdType = 1
	Split          AdminCmdType = 2
	RaftLogGC      AdminCmdType = 3
	TransferLeader AdminCmdType = 4
	ComputeHash    AdminCmdType = 5
	VerifyHash     AdminCmdType = 6
)

var AdminCmdType_name = map[int32]string{
	0: "InvalidAdmin",
	1: "ChangePeer",
	2: "Split",
	3: "RaftLogGC",
	4: "TransferLeader",
	5: "ComputeHash",
	6: "VerifyHash",
}

var AdminCmdType_value = map[string]int32{
	"InvalidAdmin":   0,
	"ChangePeer":     1,
	"Split":          2,
	"RaftLogGC":      3,
	"TransferLeader": 4,
	"ComputeHash":    5,
	"VerifyHash":     6,
}

func (x AdminCmdType) Enum() *AdminCmdType {
	p := new(AdminCmdType)
	*p = x
	return p
}

func (x AdminCmdType) String() string {
	return proto.EnumName(AdminCmdType_name, int32(x))
}

func (x *AdminCmdType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AdminCmdType_value, data, "AdminCmdType")
	if err != nil {
		return err
	}
	*x = AdminCmdType(value)
	return nil
}

func (AdminCmdType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{1}
}

type RaftRequestHeader struct {
	CellId uint64      `protobuf:"varint,1,opt,name=cellId" json:"cellId"`
	Peer   metapb.Peer `protobuf:"bytes,2,opt,name=peer" json:"peer"`
	// true for read linearizati
	ReadQuorum bool `protobuf:"varint,3,opt,name=readQuorum" json:"readQuorum"`
	// 16 bytes, to distinguish request.
	UUID                 []byte           `protobuf:"bytes,4,opt,name=uuid" json:"uuid,omitempty"`
	CellEpoch            metapb.CellEpoch `protobuf:"bytes,5,opt,name=cellEpoch" json:"cellEpoch"`
	Term                 uint64           `protobuf:"varint,6,opt,name=term" json:"term"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

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

var xxx_messageInfo_RaftRequestHeader proto.InternalMessageInfo

func (m *RaftRequestHeader) GetCellId() uint64 {
	if m != nil {
		return m.CellId
	}
	return 0
}

func (m *RaftRequestHeader) GetPeer() metapb.Peer {
	if m != nil {
		return m.Peer
	}
	return metapb.Peer{}
}

func (m *RaftRequestHeader) GetReadQuorum() bool {
	if m != nil {
		return m.ReadQuorum
	}
	return false
}

func (m *RaftRequestHeader) GetUUID() []byte {
	if m != nil {
		return m.UUID
	}
	return nil
}

func (m *RaftRequestHeader) GetCellEpoch() metapb.CellEpoch {
	if m != nil {
		return m.CellEpoch
	}
	return metapb.CellEpoch{}
}

func (m *RaftRequestHeader) GetTerm() uint64 {
	if m != nil {
		return m.Term
	}
	return 0
}

type RaftResponseHeader struct {
	Error                errorpb.Error `protobuf:"bytes,1,opt,name=error" json:"error"`
	UUID                 []byte        `protobuf:"bytes,2,opt,name=uuid" json:"uuid,omitempty"`
	CurrentTerm          uint64        `protobuf:"varint,3,opt,name=currentTerm" json:"currentTerm"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_RaftResponseHeader proto.InternalMessageInfo

func (m *RaftResponseHeader) GetError() errorpb.Error {
	if m != nil {
		return m.Error
	}
	return errorpb.Error{}
}

func (m *RaftResponseHeader) GetUUID() []byte {
	if m != nil {
		return m.UUID
	}
	return nil
}

func (m *RaftResponseHeader) GetCurrentTerm() uint64 {
	if m != nil {
		return m.CurrentTerm
	}
	return 0
}

// RaftCMDRequest we can't include both normal requests and administrator request
// at same time.
type RaftCMDRequest struct {
	Header               *RaftRequestHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	Requests             []*Request         `protobuf:"bytes,2,rep,name=requests" json:"requests,omitempty"`
	AdminRequest         *AdminRequest      `protobuf:"bytes,3,opt,name=adminRequest" json:"adminRequest,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_RaftCMDRequest proto.InternalMessageInfo

func (m *RaftCMDRequest) GetHeader() *RaftRequestHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

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

func (m *RaftCMDRequest) GetAdminRequest() *AdminRequest {
	if m != nil {
		return m.AdminRequest
	}
	return nil
}

type RaftCMDResponse struct {
	Header               *RaftResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	Responses            []*Response         `protobuf:"bytes,2,rep,name=responses" json:"responses,omitempty"`
	AdminResponse        *AdminResponse      `protobuf:"bytes,3,opt,name=adminResponse" json:"adminResponse,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_RaftCMDResponse proto.InternalMessageInfo

func (m *RaftCMDResponse) GetHeader() *RaftResponseHeader {
	if m != nil {
		return m.Header
	}
	return nil
}

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

func (m *RaftCMDResponse) GetAdminResponse() *AdminResponse {
	if m != nil {
		return m.AdminResponse
	}
	return nil
}

// admin request
type AdminRequest struct {
	Type                 AdminCmdType `protobuf:"varint,1,opt,name=type,enum=raftcmdpb.AdminCmdType" json:"type"`
	Body                 []byte       `protobuf:"bytes,2,opt,name=body" json:"body,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_AdminRequest proto.InternalMessageInfo

func (m *AdminRequest) GetType() AdminCmdType {
	if m != nil {
		return m.Type
	}
	return InvalidAdmin
}

func (m *AdminRequest) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

type AdminResponse struct {
	Type                 AdminCmdType `protobuf:"varint,1,opt,name=type,enum=raftcmdpb.AdminCmdType" json:"type"`
	Body                 []byte       `protobuf:"bytes,2,opt,name=body" json:"body,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_AdminResponse proto.InternalMessageInfo

func (m *AdminResponse) GetType() AdminCmdType {
	if m != nil {
		return m.Type
	}
	return InvalidAdmin
}

func (m *AdminResponse) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

type ChangePeerRequest struct {
	ChangeType           pdpb.ConfChangeType `protobuf:"varint,1,opt,name=changeType,enum=pdpb.ConfChangeType" json:"changeType"`
	Peer                 metapb.Peer         `protobuf:"bytes,2,opt,name=peer" json:"peer"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

var xxx_messageInfo_ChangePeerRequest proto.InternalMessageInfo

func (m *ChangePeerRequest) GetChangeType() pdpb.ConfChangeType {
	if m != nil {
		return m.ChangeType
	}
	return pdpb.AddNode
}

func (m *ChangePeerRequest) GetPeer() metapb.Peer {
	if m != nil {
		return m.Peer
	}
	return metapb.Peer{}
}

type ChangePeerResponse struct {
	Cell                 metapb.Cell `protobuf:"bytes,1,opt,name=cell" json:"cell"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *ChangePeerResponse) Reset()         { *m = ChangePeerResponse{} }
func (m *ChangePeerResponse) String() string { return proto.CompactTextString(m) }
func (*ChangePeerResponse) ProtoMessage()    {}
func (*ChangePeerResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{7}
}
func (m *ChangePeerResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChangePeerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ChangePeerResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ChangePeerResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChangePeerResponse.Merge(m, src)
}
func (m *ChangePeerResponse) XXX_Size() int {
	return m.Size()
}
func (m *ChangePeerResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ChangePeerResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ChangePeerResponse proto.InternalMessageInfo

func (m *ChangePeerResponse) GetCell() metapb.Cell {
	if m != nil {
		return m.Cell
	}
	return metapb.Cell{}
}

type SplitRequest struct {
	// This can be only called in internal RaftStore now.
	// The splitKey must be in the been splitting cell.
	SplitKey []byte `protobuf:"bytes,1,opt,name=splitKey" json:"splitKey,omitempty"`
	// We split the cell into two, first uses the origin
	// parent cell id, and the second uses the new_cell_id.
	// We must guarantee that the new_cell_id is global unique.
	NewCellID uint64 `protobuf:"varint,2,opt,name=newCellID" json:"newCellID"`
	// The peer ids for the new split cell.
	NewPeerIDs []uint64 `protobuf:"varint,3,rep,name=newPeerIDs" json:"newPeerIDs,omitempty"`
	// If true, right cell derive the origin cell_id,
	// left cell use new_cell_id.
	RightDerive          bool     `protobuf:"varint,4,opt,name=rightDerive" json:"rightDerive"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_SplitRequest proto.InternalMessageInfo

func (m *SplitRequest) GetSplitKey() []byte {
	if m != nil {
		return m.SplitKey
	}
	return nil
}

func (m *SplitRequest) GetNewCellID() uint64 {
	if m != nil {
		return m.NewCellID
	}
	return 0
}

func (m *SplitRequest) GetNewPeerIDs() []uint64 {
	if m != nil {
		return m.NewPeerIDs
	}
	return nil
}

func (m *SplitRequest) GetRightDerive() bool {
	if m != nil {
		return m.RightDerive
	}
	return false
}

type SplitResponse struct {
	Left                 metapb.Cell `protobuf:"bytes,1,opt,name=left" json:"left"`
	Right                metapb.Cell `protobuf:"bytes,2,opt,name=right" json:"right"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *SplitResponse) Reset()         { *m = SplitResponse{} }
func (m *SplitResponse) String() string { return proto.CompactTextString(m) }
func (*SplitResponse) ProtoMessage()    {}
func (*SplitResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{9}
}
func (m *SplitResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SplitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SplitResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *SplitResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SplitResponse.Merge(m, src)
}
func (m *SplitResponse) XXX_Size() int {
	return m.Size()
}
func (m *SplitResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SplitResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SplitResponse proto.InternalMessageInfo

func (m *SplitResponse) GetLeft() metapb.Cell {
	if m != nil {
		return m.Left
	}
	return metapb.Cell{}
}

func (m *SplitResponse) GetRight() metapb.Cell {
	if m != nil {
		return m.Right
	}
	return metapb.Cell{}
}

type TransferLeaderRequest struct {
	Peer                 metapb.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *TransferLeaderRequest) Reset()         { *m = TransferLeaderRequest{} }
func (m *TransferLeaderRequest) String() string { return proto.CompactTextString(m) }
func (*TransferLeaderRequest) ProtoMessage()    {}
func (*TransferLeaderRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{10}
}
func (m *TransferLeaderRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TransferLeaderRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransferLeaderRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TransferLeaderRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransferLeaderRequest.Merge(m, src)
}
func (m *TransferLeaderRequest) XXX_Size() int {
	return m.Size()
}
func (m *TransferLeaderRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_TransferLeaderRequest.DiscardUnknown(m)
}

var xxx_messageInfo_TransferLeaderRequest proto.InternalMessageInfo

func (m *TransferLeaderRequest) GetPeer() metapb.Peer {
	if m != nil {
		return m.Peer
	}
	return metapb.Peer{}
}

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

func (m *TransferLeaderResponse) Reset()         { *m = TransferLeaderResponse{} }
func (m *TransferLeaderResponse) String() string { return proto.CompactTextString(m) }
func (*TransferLeaderResponse) ProtoMessage()    {}
func (*TransferLeaderResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{11}
}
func (m *TransferLeaderResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TransferLeaderResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransferLeaderResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TransferLeaderResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransferLeaderResponse.Merge(m, src)
}
func (m *TransferLeaderResponse) XXX_Size() int {
	return m.Size()
}
func (m *TransferLeaderResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_TransferLeaderResponse.DiscardUnknown(m)
}

var xxx_messageInfo_TransferLeaderResponse proto.InternalMessageInfo

type RaftLogGCRequest struct {
	CompactIndex         uint64   `protobuf:"varint,1,opt,name=compactIndex" json:"compactIndex"`
	CompactTerm          uint64   `protobuf:"varint,2,opt,name=compactTerm" json:"compactTerm"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RaftLogGCRequest) Reset()         { *m = RaftLogGCRequest{} }
func (m *RaftLogGCRequest) String() string { return proto.CompactTextString(m) }
func (*RaftLogGCRequest) ProtoMessage()    {}
func (*RaftLogGCRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{12}
}
func (m *RaftLogGCRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RaftLogGCRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RaftLogGCRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RaftLogGCRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RaftLogGCRequest.Merge(m, src)
}
func (m *RaftLogGCRequest) XXX_Size() int {
	return m.Size()
}
func (m *RaftLogGCRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RaftLogGCRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RaftLogGCRequest proto.InternalMessageInfo

func (m *RaftLogGCRequest) GetCompactIndex() uint64 {
	if m != nil {
		return m.CompactIndex
	}
	return 0
}

func (m *RaftLogGCRequest) GetCompactTerm() uint64 {
	if m != nil {
		return m.CompactTerm
	}
	return 0
}

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

func (m *RaftLogGCResponse) Reset()         { *m = RaftLogGCResponse{} }
func (m *RaftLogGCResponse) String() string { return proto.CompactTextString(m) }
func (*RaftLogGCResponse) ProtoMessage()    {}
func (*RaftLogGCResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{13}
}
func (m *RaftLogGCResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RaftLogGCResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RaftLogGCResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RaftLogGCResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RaftLogGCResponse.Merge(m, src)
}
func (m *RaftLogGCResponse) XXX_Size() int {
	return m.Size()
}
func (m *RaftLogGCResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_RaftLogGCResponse.DiscardUnknown(m)
}

var xxx_messageInfo_RaftLogGCResponse proto.InternalMessageInfo

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

func (m *FVPair) Reset()         { *m = FVPair{} }
func (m *FVPair) String() string { return proto.CompactTextString(m) }
func (*FVPair) ProtoMessage()    {}
func (*FVPair) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{14}
}
func (m *FVPair) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FVPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FVPair.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FVPair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FVPair.Merge(m, src)
}
func (m *FVPair) XXX_Size() int {
	return m.Size()
}
func (m *FVPair) XXX_DiscardUnknown() {
	xxx_messageInfo_FVPair.DiscardUnknown(m)
}

var xxx_messageInfo_FVPair proto.InternalMessageInfo

func (m *FVPair) GetField() []byte {
	if m != nil {
		return m.Field
	}
	return nil
}

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

type ScorePair struct {
	Score                float64  `protobuf:"fixed64,1,opt,name=score" json:"score"`
	Member               []byte   `protobuf:"bytes,2,opt,name=member" json:"member,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ScorePair) Reset()         { *m = ScorePair{} }
func (m *ScorePair) String() string { return proto.CompactTextString(m) }
func (*ScorePair) ProtoMessage()    {}
func (*ScorePair) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{15}
}
func (m *ScorePair) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ScorePair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ScorePair.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ScorePair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScorePair.Merge(m, src)
}
func (m *ScorePair) XXX_Size() int {
	return m.Size()
}
func (m *ScorePair) XXX_DiscardUnknown() {
	xxx_messageInfo_ScorePair.DiscardUnknown(m)
}

var xxx_messageInfo_ScorePair proto.InternalMessageInfo

func (m *ScorePair) GetScore() float64 {
	if m != nil {
		return m.Score
	}
	return 0
}

func (m *ScorePair) GetMember() []byte {
	if m != nil {
		return m.Member
	}
	return nil
}

type Request struct {
	UUID                 []byte   `protobuf:"bytes,1,opt,name=uuid" json:"uuid,omitempty"`
	Type                 CMDType  `protobuf:"varint,2,opt,name=type,enum=raftcmdpb.CMDType" json:"type"`
	Cmd                  [][]byte `protobuf:"bytes,3,rep,name=cmd" json:"cmd,omitempty"`
	Epoch                uint64   `protobuf:"varint,4,opt,name=epoch" json:"epoch"`
	StartAt              int64    `protobuf:"varint,5,opt,name=startAt" json:"startAt"`
	LastStageAt          int64    `protobuf:"varint,6,opt,name=lastStageAt" json:"lastStageAt"`
	SessionID            int64    `protobuf:"varint,7,opt,name=sessionID" json:"sessionID"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Request) Reset()         { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage()    {}
func (*Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{16}
}
func (m *Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Request.Merge(m, src)
}
func (m *Request) XXX_Size() int {
	return m.Size()
}
func (m *Request) XXX_DiscardUnknown() {
	xxx_messageInfo_Request.DiscardUnknown(m)
}

var xxx_messageInfo_Request proto.InternalMessageInfo

func (m *Request) GetUUID() []byte {
	if m != nil {
		return m.UUID
	}
	return nil
}

func (m *Request) GetType() CMDType {
	if m != nil {
		return m.Type
	}
	return Invalid
}

func (m *Request) GetCmd() [][]byte {
	if m != nil {
		return m.Cmd
	}
	return nil
}

func (m *Request) GetEpoch() uint64 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *Request) GetStartAt() int64 {
	if m != nil {
		return m.StartAt
	}
	return 0
}

func (m *Request) GetLastStageAt() int64 {
	if m != nil {
		return m.LastStageAt
	}
	return 0
}

func (m *Request) GetSessionID() int64 {
	if m != nil {
		return m.SessionID
	}
	return 0
}

type Response struct {
	UUID                         []byte        `protobuf:"bytes,1,opt,name=uuid" json:"uuid,omitempty"`
	Type                         CMDType       `protobuf:"varint,2,opt,name=type,enum=raftcmdpb.CMDType" json:"type"`
	ErrorResult                  []byte        `protobuf:"bytes,3,opt,name=errorResult" json:"errorResult,omitempty"`
	ErrorResults                 [][]byte      `protobuf:"bytes,4,rep,name=errorResults" json:"errorResults,omitempty"`
	StatusResult                 []byte        `protobuf:"bytes,5,opt,name=statusResult" json:"statusResult,omitempty"`
	IntegerResult                *int64        `protobuf:"varint,6,opt,name=integerResult" json:"integerResult,omitempty"`
	BulkResult                   []byte        `protobuf:"bytes,7,opt,name=bulkResult" json:"bulkResult,omitempty"`
	HasEmptyBulkResult           bool          `protobuf:"varint,8,opt,name=hasEmptyBulkResult" json:"hasEmptyBulkResult"`
	SliceArrayResult             [][]byte      `protobuf:"bytes,9,rep,name=sliceArrayResult" json:"sliceArrayResult,omitempty"`
	HasEmptySliceArrayResult     bool          `protobuf:"varint,10,opt,name=hasEmptySliceArrayResult" json:"hasEmptySliceArrayResult"`
	FvPairArrayResult            []*FVPair     `protobuf:"bytes,11,rep,name=fvPairArrayResult" json:"fvPairArrayResult,omitempty"`
	HasEmptyFVPairArrayResult    bool          `protobuf:"varint,12,opt,name=hasEmptyFVPairArrayResult" json:"hasEmptyFVPairArrayResult"`
	ScorePairArrayResult         []*ScorePair  `protobuf:"bytes,13,rep,name=scorePairArrayResult" json:"scorePairArrayResult,omitempty"`
	HasEmptyScorePairArrayResult bool          `protobuf:"varint,14,opt,name=hasEmptyScorePairArrayResult" json:"hasEmptyScorePairArrayResult"`
	Withscores                   bool          `protobuf:"varint,15,opt,name=withscores" json:"withscores"`
	OriginRequest                *Request      `protobuf:"bytes,16,opt,name=originRequest" json:"originRequest,omitempty"`
	SessionID                    int64         `protobuf:"varint,17,opt,name=sessionID" json:"sessionID"`
	HasEmptyDocArrayResult       bool          `protobuf:"varint,18,opt,name=hasEmptyDocArrayResult" json:"hasEmptyDocArrayResult"`
	Error                        errorpb.Error `protobuf:"bytes,19,opt,name=error" json:"error"`
	XXX_NoUnkeyedLiteral         struct{}      `json:"-"`
	XXX_unrecognized             []byte        `json:"-"`
	XXX_sizecache                int32         `json:"-"`
}

func (m *Response) Reset()         { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage()    {}
func (*Response) Descriptor() ([]byte, []int) {
	return fileDescriptor_c4d8ad5550754569, []int{17}
}
func (m *Response) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Response.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Response) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Response.Merge(m, src)
}
func (m *Response) XXX_Size() int {
	return m.Size()
}
func (m *Response) XXX_DiscardUnknown() {
	xxx_messageInfo_Response.DiscardUnknown(m)
}

var xxx_messageInfo_Response proto.InternalMessageInfo

func (m *Response) GetUUID() []byte {
	if m != nil {
		return m.UUID
	}
	return nil
}

func (m *Response) GetType() CMDType {
	if m != nil {
		return m.Type
	}
	return Invalid
}

func (m *Response) GetErrorResult() []byte {
	if m != nil {
		return m.ErrorResult
	}
	return nil
}

func (m *Response) GetErrorResults() [][]byte {
	if m != nil {
		return m.ErrorResults
	}
	return nil
}

func (m *Response) GetStatusResult() []byte {
	if m != nil {
		return m.StatusResult
	}
	return nil
}

func (m *Response) GetIntegerResult() int64 {
	if m != nil && m.IntegerResult != nil {
		return *m.IntegerResult
	}
	return 0
}

func (m *Response) GetBulkResult() []byte {
	if m != nil {
		return m.BulkResult
	}
	return nil
}

func (m *Response) GetHasEmptyBulkResult() bool {
	if m != nil {
		return m.HasEmptyBulkResult
	}
	return false
}

func (m *Response) GetSliceArrayResult() [][]byte {
	if m != nil {
		return m.SliceArrayResult
	}
	return nil
}

func (m *Response) GetHasEmptySliceArrayResult() bool {
	if m != nil {
		return m.HasEmptySliceArrayResult
	}
	return false
}

func (m *Response) GetFvPairArrayResult() []*FVPair {
	if m != nil {
		return m.FvPairArrayResult
	}
	return nil
}

func (m *Response) GetHasEmptyFVPairArrayResult() bool {
	if m != nil {
		return m.HasEmptyFVPairArrayResult
	}
	return false
}

func (m *Response) GetScorePairArrayResult() []*ScorePair {
	if m != nil {
		return m.ScorePairArrayResult
	}
	return nil
}

func (m *Response) GetHasEmptyScorePairArrayResult() bool {
	if m != nil {
		return m.HasEmptyScorePairArrayResult
	}
	return false
}

func (m *Response) GetWithscores() bool {
	if m != nil {
		return m.Withscores
	}
	return false
}

func (m *Response) GetOriginRequest() *Request {
	if m != nil {
		return m.OriginRequest
	}
	return nil
}

func (m *Response) GetSessionID() int64 {
	if m != nil {
		return m.SessionID
	}
	return 0
}

func (m *Response) GetHasEmptyDocArrayResult() bool {
	if m != nil {
		return m.HasEmptyDocArrayResult
	}
	return false
}

func (m *Response) GetError() errorpb.Error {
	if m != nil {
		return m.Error
	}
	return errorpb.Error{}
}

func init() {
	proto.RegisterEnum("raftcmdpb.CMDType", CMDType_name, CMDType_value)
	proto.RegisterEnum("raftcmdpb.AdminCmdType", AdminCmdType_name, AdminCmdType_value)
	proto.RegisterType((*RaftRequestHeader)(nil), "raftcmdpb.RaftRequestHeader")
	proto.RegisterType((*RaftResponseHeader)(nil), "raftcmdpb.RaftResponseHeader")
	proto.RegisterType((*RaftCMDRequest)(nil), "raftcmdpb.RaftCMDRequest")
	proto.RegisterType((*RaftCMDResponse)(nil), "raftcmdpb.RaftCMDResponse")
	proto.RegisterType((*AdminRequest)(nil), "raftcmdpb.AdminRequest")
	proto.RegisterType((*AdminResponse)(nil), "raftcmdpb.AdminResponse")
	proto.RegisterType((*ChangePeerRequest)(nil), "raftcmdpb.ChangePeerRequest")
	proto.RegisterType((*ChangePeerResponse)(nil), "raftcmdpb.ChangePeerResponse")
	proto.RegisterType((*SplitRequest)(nil), "raftcmdpb.SplitRequest")
	proto.RegisterType((*SplitResponse)(nil), "raftcmdpb.SplitResponse")
	proto.RegisterType((*TransferLeaderRequest)(nil), "raftcmdpb.TransferLeaderRequest")
	proto.RegisterType((*TransferLeaderResponse)(nil), "raftcmdpb.TransferLeaderResponse")
	proto.RegisterType((*RaftLogGCRequest)(nil), "raftcmdpb.RaftLogGCRequest")
	proto.RegisterType((*RaftLogGCResponse)(nil), "raftcmdpb.RaftLogGCResponse")
	proto.RegisterType((*FVPair)(nil), "raftcmdpb.FVPair")
	proto.RegisterType((*ScorePair)(nil), "raftcmdpb.ScorePair")
	proto.RegisterType((*Request)(nil), "raftcmdpb.Request")
	proto.RegisterType((*Response)(nil), "raftcmdpb.Response")
}

func init() { proto.RegisterFile("raftcmdpb.proto", fileDescriptor_c4d8ad5550754569) }

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

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

func (m *RaftRequestHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RaftRequestHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.Term))
	i--
	dAtA[i] = 0x30
	{
		size, err := m.CellEpoch.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.UUID != nil {
		i -= len(m.UUID)
		copy(dAtA[i:], m.UUID)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.UUID)))
		i--
		dAtA[i] = 0x22
	}
	i--
	if m.ReadQuorum {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x18
	{
		size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.CellId))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

func (m *RaftResponseHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RaftResponseHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.CurrentTerm))
	i--
	dAtA[i] = 0x18
	if m.UUID != nil {
		i -= len(m.UUID)
		copy(dAtA[i:], m.UUID)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.UUID)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *RaftCMDRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RaftCMDRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.AdminRequest != nil {
		{
			size, err := m.AdminRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Requests) > 0 {
		for iNdEx := len(m.Requests) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Requests[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Header != nil {
		{
			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RaftCMDResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RaftCMDResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.AdminResponse != nil {
		{
			size, err := m.AdminResponse.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Responses) > 0 {
		for iNdEx := len(m.Responses) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Responses[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Header != nil {
		{
			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AdminRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AdminRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Body != nil {
		i -= len(m.Body)
		copy(dAtA[i:], m.Body)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.Body)))
		i--
		dAtA[i] = 0x12
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.Type))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

func (m *AdminResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Body != nil {
		i -= len(m.Body)
		copy(dAtA[i:], m.Body)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.Body)))
		i--
		dAtA[i] = 0x12
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.Type))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

func (m *ChangePeerRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangePeerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.ChangeType))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

func (m *ChangePeerResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ChangePeerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Cell.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *SplitRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SplitRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	i--
	if m.RightDerive {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x20
	if len(m.NewPeerIDs) > 0 {
		for iNdEx := len(m.NewPeerIDs) - 1; iNdEx >= 0; iNdEx-- {
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.NewPeerIDs[iNdEx]))
			i--
			dAtA[i] = 0x18
		}
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.NewCellID))
	i--
	dAtA[i] = 0x10
	if m.SplitKey != nil {
		i -= len(m.SplitKey)
		copy(dAtA[i:], m.SplitKey)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.SplitKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SplitResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *SplitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Right.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Left.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *TransferLeaderRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransferLeaderRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Peer.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *TransferLeaderResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransferLeaderResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

func (m *RaftLogGCRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RaftLogGCRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.CompactTerm))
	i--
	dAtA[i] = 0x10
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.CompactIndex))
	i--
	dAtA[i] = 0x8
	return len(dAtA) - i, nil
}

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

func (m *RaftLogGCResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RaftLogGCResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

func (m *FVPair) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FVPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Value != nil {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if m.Field != nil {
		i -= len(m.Field)
		copy(dAtA[i:], m.Field)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.Field)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ScorePair) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ScorePair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Member != nil {
		i -= len(m.Member)
		copy(dAtA[i:], m.Member)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.Member)))
		i--
		dAtA[i] = 0x12
	}
	i -= 8
	encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Score))))
	i--
	dAtA[i] = 0x9
	return len(dAtA) - i, nil
}

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

func (m *Request) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.SessionID))
	i--
	dAtA[i] = 0x38
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.LastStageAt))
	i--
	dAtA[i] = 0x30
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.StartAt))
	i--
	dAtA[i] = 0x28
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.Epoch))
	i--
	dAtA[i] = 0x20
	if len(m.Cmd) > 0 {
		for iNdEx := len(m.Cmd) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Cmd[iNdEx])
			copy(dAtA[i:], m.Cmd[iNdEx])
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.Cmd[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.Type))
	i--
	dAtA[i] = 0x10
	if m.UUID != nil {
		i -= len(m.UUID)
		copy(dAtA[i:], m.UUID)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.UUID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Response) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x9a
	i--
	if m.HasEmptyDocArrayResult {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x90
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.SessionID))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x88
	if m.OriginRequest != nil {
		{
			size, err := m.OriginRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	i--
	if m.Withscores {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x78
	i--
	if m.HasEmptyScorePairArrayResult {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x70
	if len(m.ScorePairArrayResult) > 0 {
		for iNdEx := len(m.ScorePairArrayResult) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ScorePairArrayResult[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x6a
		}
	}
	i--
	if m.HasEmptyFVPairArrayResult {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x60
	if len(m.FvPairArrayResult) > 0 {
		for iNdEx := len(m.FvPairArrayResult) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FvPairArrayResult[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRaftcmdpb(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	i--
	if m.HasEmptySliceArrayResult {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x50
	if len(m.SliceArrayResult) > 0 {
		for iNdEx := len(m.SliceArrayResult) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.SliceArrayResult[iNdEx])
			copy(dAtA[i:], m.SliceArrayResult[iNdEx])
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.SliceArrayResult[iNdEx])))
			i--
			dAtA[i] = 0x4a
		}
	}
	i--
	if m.HasEmptyBulkResult {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i--
	dAtA[i] = 0x40
	if m.BulkResult != nil {
		i -= len(m.BulkResult)
		copy(dAtA[i:], m.BulkResult)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.BulkResult)))
		i--
		dAtA[i] = 0x3a
	}
	if m.IntegerResult != nil {
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(*m.IntegerResult))
		i--
		dAtA[i] = 0x30
	}
	if m.StatusResult != nil {
		i -= len(m.StatusResult)
		copy(dAtA[i:], m.StatusResult)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.StatusResult)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ErrorResults) > 0 {
		for iNdEx := len(m.ErrorResults) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ErrorResults[iNdEx])
			copy(dAtA[i:], m.ErrorResults[iNdEx])
			i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.ErrorResults[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.ErrorResult != nil {
		i -= len(m.ErrorResult)
		copy(dAtA[i:], m.ErrorResult)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.ErrorResult)))
		i--
		dAtA[i] = 0x1a
	}
	i = encodeVarintRaftcmdpb(dAtA, i, uint64(m.Type))
	i--
	dAtA[i] = 0x10
	if m.UUID != nil {
		i -= len(m.UUID)
		copy(dAtA[i:], m.UUID)
		i = encodeVarintRaftcmdpb(dAtA, i, uint64(len(m.UUID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintRaftcmdpb(dAtA []byte, offset int, v uint64) int {
	offset -= sovRaftcmdpb(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *RaftRequestHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaftcmdpb(uint64(m.CellId))
	l = m.Peer.Size()
	n += 1 + l + sovRaftcmdpb(uint64(l))
	n += 2
	if m.UUID != nil {
		l = len(m.UUID)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	l = m.CellEpoch.Size()
	n += 1 + l + sovRaftcmdpb(uint64(l))
	n += 1 + sovRaftcmdpb(uint64(m.Term))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftResponseHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Error.Size()
	n += 1 + l + sovRaftcmdpb(uint64(l))
	if m.UUID != nil {
		l = len(m.UUID)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	n += 1 + sovRaftcmdpb(uint64(m.CurrentTerm))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftCMDRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if len(m.Requests) > 0 {
		for _, e := range m.Requests {
			l = e.Size()
			n += 1 + l + sovRaftcmdpb(uint64(l))
		}
	}
	if m.AdminRequest != nil {
		l = m.AdminRequest.Size()
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftCMDResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if len(m.Responses) > 0 {
		for _, e := range m.Responses {
			l = e.Size()
			n += 1 + l + sovRaftcmdpb(uint64(l))
		}
	}
	if m.AdminResponse != nil {
		l = m.AdminResponse.Size()
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AdminRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaftcmdpb(uint64(m.Type))
	if m.Body != nil {
		l = len(m.Body)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AdminResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaftcmdpb(uint64(m.Type))
	if m.Body != nil {
		l = len(m.Body)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChangePeerRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaftcmdpb(uint64(m.ChangeType))
	l = m.Peer.Size()
	n += 1 + l + sovRaftcmdpb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *SplitRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SplitKey != nil {
		l = len(m.SplitKey)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	n += 1 + sovRaftcmdpb(uint64(m.NewCellID))
	if len(m.NewPeerIDs) > 0 {
		for _, e := range m.NewPeerIDs {
			n += 1 + sovRaftcmdpb(uint64(e))
		}
	}
	n += 2
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SplitResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Left.Size()
	n += 1 + l + sovRaftcmdpb(uint64(l))
	l = m.Right.Size()
	n += 1 + l + sovRaftcmdpb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *RaftLogGCRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaftcmdpb(uint64(m.CompactIndex))
	n += 1 + sovRaftcmdpb(uint64(m.CompactTerm))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *ScorePair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 9
	if m.Member != nil {
		l = len(m.Member)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UUID != nil {
		l = len(m.UUID)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	n += 1 + sovRaftcmdpb(uint64(m.Type))
	if len(m.Cmd) > 0 {
		for _, b := range m.Cmd {
			l = len(b)
			n += 1 + l + sovRaftcmdpb(uint64(l))
		}
	}
	n += 1 + sovRaftcmdpb(uint64(m.Epoch))
	n += 1 + sovRaftcmdpb(uint64(m.StartAt))
	n += 1 + sovRaftcmdpb(uint64(m.LastStageAt))
	n += 1 + sovRaftcmdpb(uint64(m.SessionID))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Response) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.UUID != nil {
		l = len(m.UUID)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	n += 1 + sovRaftcmdpb(uint64(m.Type))
	if m.ErrorResult != nil {
		l = len(m.ErrorResult)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if len(m.ErrorResults) > 0 {
		for _, b := range m.ErrorResults {
			l = len(b)
			n += 1 + l + sovRaftcmdpb(uint64(l))
		}
	}
	if m.StatusResult != nil {
		l = len(m.StatusResult)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	if m.IntegerResult != nil {
		n += 1 + sovRaftcmdpb(uint64(*m.IntegerResult))
	}
	if m.BulkResult != nil {
		l = len(m.BulkResult)
		n += 1 + l + sovRaftcmdpb(uint64(l))
	}
	n += 2
	if len(m.SliceArrayResult) > 0 {
		for _, b := range m.SliceArrayResult {
			l = len(b)
			n += 1 + l + sovRaftcmdpb(uint64(l))
		}
	}
	n += 2
	if len(m.FvPairArrayResult) > 0 {
		for _, e := range m.FvPairArrayResult {
			l = e.Size()
			n += 1 + l + sovRaftcmdpb(uint64(l))
		}
	}
	n += 2
	if len(m.ScorePairArrayResult) > 0 {
		for _, e := range m.ScorePairArrayResult {
			l = e.Size()
			n += 1 + l + sovRaftcmdpb(uint64(l))
		}
	}
	n += 2
	n += 2
	if m.OriginRequest != nil {
		l = m.OriginRequest.Size()
		n += 2 + l + sovRaftcmdpb(uint64(l))
	}
	n += 2 + sovRaftcmdpb(uint64(m.SessionID))
	n += 3
	l = m.Error.Size()
	n += 2 + l + sovRaftcmdpb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovRaftcmdpb(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRaftcmdpb(x uint64) (n int) {
	return sovRaftcmdpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RaftRequestHeader) 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 ErrIntOverflowRaftcmdpb
			}
			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: RaftRequestHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftRequestHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellId", wireType)
			}
			m.CellId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CellId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadQuorum", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ReadQuorum = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UUID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UUID = append(m.UUID[:0], dAtA[iNdEx:postIndex]...)
			if m.UUID == nil {
				m.UUID = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellEpoch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.CellEpoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
			}
			m.Term = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Term |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *RaftResponseHeader) 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 ErrIntOverflowRaftcmdpb
			}
			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: RaftResponseHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UUID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UUID = append(m.UUID[:0], dAtA[iNdEx:postIndex]...)
			if m.UUID == nil {
				m.UUID = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CurrentTerm", wireType)
			}
			m.CurrentTerm = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CurrentTerm |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *RaftCMDRequest) 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 ErrIntOverflowRaftcmdpb
			}
			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: RaftCMDRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftCMDRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &RaftRequestHeader{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requests = append(m.Requests, &Request{})
			if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AdminRequest == nil {
				m.AdminRequest = &AdminRequest{}
			}
			if err := m.AdminRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *RaftCMDResponse) 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 ErrIntOverflowRaftcmdpb
			}
			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: RaftCMDResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftCMDResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &RaftResponseHeader{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Responses = append(m.Responses, &Response{})
			if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AdminResponse", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AdminResponse == nil {
				m.AdminResponse = &AdminResponse{}
			}
			if err := m.AdminResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *AdminRequest) 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 ErrIntOverflowRaftcmdpb
			}
			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: AdminRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AdminRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= AdminCmdType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Body = append(m.Body[:0], dAtA[iNdEx:postIndex]...)
			if m.Body == nil {
				m.Body = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *AdminResponse) 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 ErrIntOverflowRaftcmdpb
			}
			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: AdminResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AdminResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= AdminCmdType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Body = append(m.Body[:0], dAtA[iNdEx:postIndex]...)
			if m.Body == nil {
				m.Body = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *ChangePeerRequest) 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 ErrIntOverflowRaftcmdpb
			}
			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: ChangePeerRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChangePeerRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType)
			}
			m.ChangeType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChangeType |= pdpb.ConfChangeType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *ChangePeerResponse) 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 ErrIntOverflowRaftcmdpb
			}
			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: ChangePeerResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChangePeerResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cell", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Cell.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *SplitRequest) 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 ErrIntOverflowRaftcmdpb
			}
			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: SplitRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SplitRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SplitKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SplitKey = append(m.SplitKey[:0], dAtA[iNdEx:postIndex]...)
			if m.SplitKey == nil {
				m.SplitKey = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewCellID", wireType)
			}
			m.NewCellID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NewCellID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRaftcmdpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.NewPeerIDs = append(m.NewPeerIDs, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowRaftcmdpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthRaftcmdpb
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthRaftcmdpb
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.NewPeerIDs) == 0 {
					m.NewPeerIDs = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowRaftcmdpb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.NewPeerIDs = append(m.NewPeerIDs, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field NewPeerIDs", wireType)
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RightDerive", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RightDerive = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *SplitResponse) 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 ErrIntOverflowRaftcmdpb
			}
			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: SplitResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SplitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Left", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Left.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Right", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Right.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *TransferLeaderRequest) 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 ErrIntOverflowRaftcmdpb
			}
			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: TransferLeaderRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransferLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Peer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *TransferLeaderResponse) 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 ErrIntOverflowRaftcmdpb
			}
			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: TransferLeaderResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransferLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *RaftLogGCRequest) 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 ErrIntOverflowRaftcmdpb
			}
			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: RaftLogGCRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftLogGCRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompactIndex", wireType)
			}
			m.CompactIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompactIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompactTerm", wireType)
			}
			m.CompactTerm = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompactTerm |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *RaftLogGCResponse) 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 ErrIntOverflowRaftcmdpb
			}
			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: RaftLogGCResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftLogGCResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *FVPair) 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 ErrIntOverflowRaftcmdpb
			}
			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: FVPair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FVPair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Field", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Field = append(m.Field[:0], dAtA[iNdEx:postIndex]...)
			if m.Field == nil {
				m.Field = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *ScorePair) 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 ErrIntOverflowRaftcmdpb
			}
			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: ScorePair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ScorePair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Score", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Score = float64(math.Float64frombits(v))
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Member = append(m.Member[:0], dAtA[iNdEx:postIndex]...)
			if m.Member == nil {
				m.Member = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *Request) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftcmdpb
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UUID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UUID = append(m.UUID[:0], dAtA[iNdEx:postIndex]...)
			if m.UUID == nil {
				m.UUID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= CMDType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cmd", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cmd = append(m.Cmd, make([]byte, postIndex-iNdEx))
			copy(m.Cmd[len(m.Cmd)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartAt", wireType)
			}
			m.StartAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastStageAt", wireType)
			}
			m.LastStageAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastStageAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionID", wireType)
			}
			m.SessionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SessionID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 *Response) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRaftcmdpb
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UUID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UUID = append(m.UUID[:0], dAtA[iNdEx:postIndex]...)
			if m.UUID == nil {
				m.UUID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= CMDType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorResult", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ErrorResult = append(m.ErrorResult[:0], dAtA[iNdEx:postIndex]...)
			if m.ErrorResult == nil {
				m.ErrorResult = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorResults", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ErrorResults = append(m.ErrorResults, make([]byte, postIndex-iNdEx))
			copy(m.ErrorResults[len(m.ErrorResults)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusResult", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StatusResult = append(m.StatusResult[:0], dAtA[iNdEx:postIndex]...)
			if m.StatusResult == nil {
				m.StatusResult = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntegerResult", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IntegerResult = &v
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BulkResult", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BulkResult = append(m.BulkResult[:0], dAtA[iNdEx:postIndex]...)
			if m.BulkResult == nil {
				m.BulkResult = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasEmptyBulkResult", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasEmptyBulkResult = bool(v != 0)
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SliceArrayResult", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SliceArrayResult = append(m.SliceArrayResult, make([]byte, postIndex-iNdEx))
			copy(m.SliceArrayResult[len(m.SliceArrayResult)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasEmptySliceArrayResult", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasEmptySliceArrayResult = bool(v != 0)
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FvPairArrayResult", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FvPairArrayResult = append(m.FvPairArrayResult, &FVPair{})
			if err := m.FvPairArrayResult[len(m.FvPairArrayResult)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasEmptyFVPairArrayResult", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasEmptyFVPairArrayResult = bool(v != 0)
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ScorePairArrayResult", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ScorePairArrayResult = append(m.ScorePairArrayResult, &ScorePair{})
			if err := m.ScorePairArrayResult[len(m.ScorePairArrayResult)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasEmptyScorePairArrayResult", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasEmptyScorePairArrayResult = bool(v != 0)
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Withscores", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Withscores = bool(v != 0)
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OriginRequest == nil {
				m.OriginRequest = &Request{}
			}
			if err := m.OriginRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SessionID", wireType)
			}
			m.SessionID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SessionID |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HasEmptyDocArrayResult", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HasEmptyDocArrayResult = bool(v != 0)
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaftcmdpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthRaftcmdpb
			}
			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 skipRaftcmdpb(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, ErrIntOverflowRaftcmdpb
			}
			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, ErrIntOverflowRaftcmdpb
				}
				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, ErrIntOverflowRaftcmdpb
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthRaftcmdpb
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthRaftcmdpb
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowRaftcmdpb
					}
					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 := skipRaftcmdpb(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthRaftcmdpb
				}
			}
			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 (
	ErrInvalidLengthRaftcmdpb = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRaftcmdpb   = fmt.Errorf("proto: integer overflow")
)