pb.pb.go

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

/*
	Package raft is a generated protocol buffer package.

	It is generated from these files:
		pb.proto

	It has these top-level messages:
		DBLocalState
		RaftLocalState
		RaftApplyState
		RaftTruncatedState
		RaftMessage
		SnapshotMessageHeader
		SnapshotMessage
		SnapshotChunkMessage
		RaftRequestHeader
		RaftCMDRequest
		AdminRequest
		AdminResponse
		ChangePeerRequest
		ChangePeerResponse
		SplitRequest
		SplitResponse
		TransferLeaderRequest
		TransferLeaderResponse
		CompactLogRequest
		CompactLogResponse
*/
package raft

import (
	"fmt"

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

	math "math"

	rpc "github.com/infinivision/hyena/pkg/pb/rpc"

	meta "github.com/infinivision/hyena/pkg/pb/meta"

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

	raftpb "github.com/coreos/etcd/raft/raftpb"

	io "io"
)

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

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

// PeerState peer state
type PeerState int32

const (
	Normal    PeerState = 0
	Applying  PeerState = 1
	Tombstone PeerState = 2
)

var PeerState_name = map[int32]string{
	0: "Normal",
	1: "Applying",
	2: "Tombstone",
}
var PeerState_value = map[string]int32{
	"Normal":    0,
	"Applying":  1,
	"Tombstone": 2,
}

func (x PeerState) Enum() *PeerState {
	p := new(PeerState)
	*p = x
	return p
}
func (x PeerState) String() string {
	return proto.EnumName(PeerState_name, int32(x))
}
func (x *PeerState) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(PeerState_value, data, "PeerState")
	if err != nil {
		return err
	}
	*x = PeerState(value)
	return nil
}
func (PeerState) EnumDescriptor() ([]byte, []int) { return fileDescriptorPb, []int{0} }

// AdminCmdType raft cmd type
type AdminCmdType int32

const (
	ChangePeer     AdminCmdType = 0
	Split          AdminCmdType = 1
	CompactLog     AdminCmdType = 2
	TransferLeader AdminCmdType = 3
)

var AdminCmdType_name = map[int32]string{
	0: "ChangePeer",
	1: "Split",
	2: "CompactLog",
	3: "TransferLeader",
}
var AdminCmdType_value = map[string]int32{
	"ChangePeer":     0,
	"Split":          1,
	"CompactLog":     2,
	"TransferLeader": 3,
}

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 fileDescriptorPb, []int{1} }

// DBLocalState vectordb local state
type DBLocalState struct {
	State            PeerState     `protobuf:"varint,1,opt,name=state,enum=raft.PeerState" json:"state"`
	DB               meta.VectorDB `protobuf:"bytes,2,opt,name=db" json:"db"`
	XXX_unrecognized []byte        `json:"-"`
}

func (m *DBLocalState) Reset()                    { *m = DBLocalState{} }
func (m *DBLocalState) String() string            { return proto.CompactTextString(m) }
func (*DBLocalState) ProtoMessage()               {}
func (*DBLocalState) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{0} }

func (m *DBLocalState) GetState() PeerState {
	if m != nil {
		return m.State
	}
	return Normal
}

func (m *DBLocalState) GetDB() meta.VectorDB {
	if m != nil {
		return m.DB
	}
	return meta.VectorDB{}
}

// RaftLocalState raft local state
type RaftLocalState struct {
	HardState        raftpb.HardState `protobuf:"bytes,1,opt,name=hardState" json:"hardState"`
	LastIndex        uint64           `protobuf:"varint,2,opt,name=lastIndex" json:"lastIndex"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *RaftLocalState) Reset()                    { *m = RaftLocalState{} }
func (m *RaftLocalState) String() string            { return proto.CompactTextString(m) }
func (*RaftLocalState) ProtoMessage()               {}
func (*RaftLocalState) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{1} }

func (m *RaftLocalState) GetHardState() raftpb.HardState {
	if m != nil {
		return m.HardState
	}
	return raftpb.HardState{}
}

func (m *RaftLocalState) GetLastIndex() uint64 {
	if m != nil {
		return m.LastIndex
	}
	return 0
}

// RaftApplyState raft apply state
type RaftApplyState struct {
	AppliedIndex     uint64             `protobuf:"varint,1,opt,name=appliedIndex" json:"appliedIndex"`
	TruncatedState   RaftTruncatedState `protobuf:"bytes,2,opt,name=truncatedState" json:"truncatedState"`
	CommittedOffset  int64              `protobuf:"varint,3,opt,name=committedOffset" json:"committedOffset"`
	CommittedIndex   int64              `protobuf:"varint,4,opt,name=committedIndex" json:"committedIndex"`
	XXX_unrecognized []byte             `json:"-"`
}

func (m *RaftApplyState) Reset()                    { *m = RaftApplyState{} }
func (m *RaftApplyState) String() string            { return proto.CompactTextString(m) }
func (*RaftApplyState) ProtoMessage()               {}
func (*RaftApplyState) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{2} }

func (m *RaftApplyState) GetAppliedIndex() uint64 {
	if m != nil {
		return m.AppliedIndex
	}
	return 0
}

func (m *RaftApplyState) GetTruncatedState() RaftTruncatedState {
	if m != nil {
		return m.TruncatedState
	}
	return RaftTruncatedState{}
}

func (m *RaftApplyState) GetCommittedOffset() int64 {
	if m != nil {
		return m.CommittedOffset
	}
	return 0
}

func (m *RaftApplyState) GetCommittedIndex() int64 {
	if m != nil {
		return m.CommittedIndex
	}
	return 0
}

// RaftTruncatedState raft snapshot state
type RaftTruncatedState struct {
	Index            uint64 `protobuf:"varint,1,opt,name=index" json:"index"`
	Term             uint64 `protobuf:"varint,2,opt,name=term" json:"term"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *RaftTruncatedState) Reset()                    { *m = RaftTruncatedState{} }
func (m *RaftTruncatedState) String() string            { return proto.CompactTextString(m) }
func (*RaftTruncatedState) ProtoMessage()               {}
func (*RaftTruncatedState) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{3} }

func (m *RaftTruncatedState) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

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

// RaftMessage wrapper etcd raft msg for multi-raft
type RaftMessage struct {
	ID               uint64         `protobuf:"varint,1,opt,name=id" json:"id"`
	From             meta.Peer      `protobuf:"bytes,2,opt,name=from" json:"from"`
	To               meta.Peer      `protobuf:"bytes,3,opt,name=to" json:"to"`
	Epoch            meta.Epoch     `protobuf:"bytes,4,opt,name=epoch" json:"epoch"`
	Start            uint64         `protobuf:"varint,5,opt,name=start" json:"start"`
	DBState          meta.DBState   `protobuf:"varint,6,opt,name=dbState,enum=meta.DBState" json:"dbState"`
	Tombstone        bool           `protobuf:"varint,7,opt,name=tombstone" json:"tombstone"`
	Message          raftpb.Message `protobuf:"bytes,8,opt,name=message" json:"message"`
	XXX_unrecognized []byte         `json:"-"`
}

func (m *RaftMessage) Reset()                    { *m = RaftMessage{} }
func (m *RaftMessage) String() string            { return proto.CompactTextString(m) }
func (*RaftMessage) ProtoMessage()               {}
func (*RaftMessage) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{4} }

func (m *RaftMessage) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *RaftMessage) GetFrom() meta.Peer {
	if m != nil {
		return m.From
	}
	return meta.Peer{}
}

func (m *RaftMessage) GetTo() meta.Peer {
	if m != nil {
		return m.To
	}
	return meta.Peer{}
}

func (m *RaftMessage) GetEpoch() meta.Epoch {
	if m != nil {
		return m.Epoch
	}
	return meta.Epoch{}
}

func (m *RaftMessage) GetStart() uint64 {
	if m != nil {
		return m.Start
	}
	return 0
}

func (m *RaftMessage) GetDBState() meta.DBState {
	if m != nil {
		return m.DBState
	}
	return meta.RU
}

func (m *RaftMessage) GetTombstone() bool {
	if m != nil {
		return m.Tombstone
	}
	return false
}

func (m *RaftMessage) GetMessage() raftpb.Message {
	if m != nil {
		return m.Message
	}
	return raftpb.Message{}
}

// SnapshotMessageHeader snapshot header
type SnapshotMessageHeader struct {
	DB               meta.VectorDB `protobuf:"bytes,1,opt,name=db" json:"db"`
	From             meta.Peer     `protobuf:"bytes,2,opt,name=from" json:"from"`
	To               meta.Peer     `protobuf:"bytes,3,opt,name=to" json:"to"`
	Term             uint64        `protobuf:"varint,4,opt,name=term" json:"term"`
	Index            uint64        `protobuf:"varint,5,opt,name=index" json:"index"`
	Seq              uint64        `protobuf:"varint,6,opt,name=seq" json:"seq"`
	CommittedOffset  int64         `protobuf:"varint,7,opt,name=committedOffset" json:"committedOffset"`
	CommittedIndex   int64         `protobuf:"varint,8,opt,name=committedIndex" json:"committedIndex"`
	XXX_unrecognized []byte        `json:"-"`
}

func (m *SnapshotMessageHeader) Reset()                    { *m = SnapshotMessageHeader{} }
func (m *SnapshotMessageHeader) String() string            { return proto.CompactTextString(m) }
func (*SnapshotMessageHeader) ProtoMessage()               {}
func (*SnapshotMessageHeader) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{5} }

func (m *SnapshotMessageHeader) GetDB() meta.VectorDB {
	if m != nil {
		return m.DB
	}
	return meta.VectorDB{}
}

func (m *SnapshotMessageHeader) GetFrom() meta.Peer {
	if m != nil {
		return m.From
	}
	return meta.Peer{}
}

func (m *SnapshotMessageHeader) GetTo() meta.Peer {
	if m != nil {
		return m.To
	}
	return meta.Peer{}
}

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

func (m *SnapshotMessageHeader) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *SnapshotMessageHeader) GetSeq() uint64 {
	if m != nil {
		return m.Seq
	}
	return 0
}

func (m *SnapshotMessageHeader) GetCommittedOffset() int64 {
	if m != nil {
		return m.CommittedOffset
	}
	return 0
}

func (m *SnapshotMessageHeader) GetCommittedIndex() int64 {
	if m != nil {
		return m.CommittedIndex
	}
	return 0
}

// SnapshotMessage message
type SnapshotMessage struct {
	Header           SnapshotMessageHeader `protobuf:"bytes,1,opt,name=header" json:"header"`
	Chunk            *SnapshotChunkMessage `protobuf:"bytes,2,opt,name=chunk" json:"chunk,omitempty"`
	XXX_unrecognized []byte                `json:"-"`
}

func (m *SnapshotMessage) Reset()                    { *m = SnapshotMessage{} }
func (m *SnapshotMessage) String() string            { return proto.CompactTextString(m) }
func (*SnapshotMessage) ProtoMessage()               {}
func (*SnapshotMessage) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{6} }

func (m *SnapshotMessage) GetHeader() SnapshotMessageHeader {
	if m != nil {
		return m.Header
	}
	return SnapshotMessageHeader{}
}

func (m *SnapshotMessage) GetChunk() *SnapshotChunkMessage {
	if m != nil {
		return m.Chunk
	}
	return nil
}

// SnapshotChunkMessage chunk message
type SnapshotChunkMessage struct {
	Data             []byte `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
	First            bool   `protobuf:"varint,2,opt,name=first" json:"first"`
	Last             bool   `protobuf:"varint,3,opt,name=last" json:"last"`
	FileSize         uint64 `protobuf:"varint,4,opt,name=fileSize" json:"fileSize"`
	CheckSum         uint64 `protobuf:"varint,5,opt,name=checkSum" json:"checkSum"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *SnapshotChunkMessage) Reset()                    { *m = SnapshotChunkMessage{} }
func (m *SnapshotChunkMessage) String() string            { return proto.CompactTextString(m) }
func (*SnapshotChunkMessage) ProtoMessage()               {}
func (*SnapshotChunkMessage) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{7} }

func (m *SnapshotChunkMessage) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *SnapshotChunkMessage) GetFirst() bool {
	if m != nil {
		return m.First
	}
	return false
}

func (m *SnapshotChunkMessage) GetLast() bool {
	if m != nil {
		return m.Last
	}
	return false
}

func (m *SnapshotChunkMessage) GetFileSize() uint64 {
	if m != nil {
		return m.FileSize
	}
	return 0
}

func (m *SnapshotChunkMessage) GetCheckSum() uint64 {
	if m != nil {
		return m.CheckSum
	}
	return 0
}

type RaftRequestHeader struct {
	ID               uint64     `protobuf:"varint,1,opt,name=id" json:"id"`
	UUID             []byte     `protobuf:"bytes,2,opt,name=uuid" json:"uuid,omitempty"`
	Peer             meta.Peer  `protobuf:"bytes,3,opt,name=peer" json:"peer"`
	Epoch            meta.Epoch `protobuf:"bytes,4,opt,name=epoch" json:"epoch"`
	Term             uint64     `protobuf:"varint,5,opt,name=term" json:"term"`
	XXX_unrecognized []byte     `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 fileDescriptorPb, []int{8} }

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

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

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

func (m *RaftRequestHeader) GetEpoch() meta.Epoch {
	if m != nil {
		return m.Epoch
	}
	return meta.Epoch{}
}

func (m *RaftRequestHeader) GetTerm() uint64 {
	if m != nil {
		return m.Term
	}
	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"`
	Inserts          []*rpc.InsertRequest `protobuf:"bytes,2,rep,name=inserts" json:"inserts,omitempty"`
	Updates          []*rpc.UpdateRequest `protobuf:"bytes,3,rep,name=updates" json:"updates,omitempty"`
	Admin            *AdminRequest        `protobuf:"bytes,4,opt,name=admin" json:"admin,omitempty"`
	XXX_unrecognized []byte               `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 fileDescriptorPb, []int{9} }

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

func (m *RaftCMDRequest) GetInserts() []*rpc.InsertRequest {
	if m != nil {
		return m.Inserts
	}
	return nil
}

func (m *RaftCMDRequest) GetUpdates() []*rpc.UpdateRequest {
	if m != nil {
		return m.Updates
	}
	return nil
}

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

type AdminRequest struct {
	Type             AdminCmdType           `protobuf:"varint,1,opt,name=type,enum=raft.AdminCmdType" json:"type"`
	ChangePeer       *ChangePeerRequest     `protobuf:"bytes,2,opt,name=changePeer" json:"changePeer,omitempty"`
	Split            *SplitRequest          `protobuf:"bytes,3,opt,name=split" json:"split,omitempty"`
	TransferLeader   *TransferLeaderRequest `protobuf:"bytes,4,opt,name=transferLeader" json:"transferLeader,omitempty"`
	CompactLog       *CompactLogRequest     `protobuf:"bytes,5,opt,name=compactLog" json:"compactLog,omitempty"`
	XXX_unrecognized []byte                 `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 fileDescriptorPb, []int{10} }

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

func (m *AdminRequest) GetChangePeer() *ChangePeerRequest {
	if m != nil {
		return m.ChangePeer
	}
	return nil
}

func (m *AdminRequest) GetSplit() *SplitRequest {
	if m != nil {
		return m.Split
	}
	return nil
}

func (m *AdminRequest) GetTransferLeader() *TransferLeaderRequest {
	if m != nil {
		return m.TransferLeader
	}
	return nil
}

func (m *AdminRequest) GetCompactLog() *CompactLogRequest {
	if m != nil {
		return m.CompactLog
	}
	return nil
}

type AdminResponse struct {
	Type             AdminCmdType            `protobuf:"varint,1,opt,name=type,enum=raft.AdminCmdType" json:"type"`
	ChangePeer       *ChangePeerResponse     `protobuf:"bytes,2,opt,name=changePeer" json:"changePeer,omitempty"`
	Split            *SplitResponse          `protobuf:"bytes,3,opt,name=split" json:"split,omitempty"`
	TransferLeader   *TransferLeaderResponse `protobuf:"bytes,4,opt,name=transferLeader" json:"transferLeader,omitempty"`
	CompactLog       *CompactLogResponse     `protobuf:"bytes,5,opt,name=compactLog" json:"compactLog,omitempty"`
	XXX_unrecognized []byte                  `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 fileDescriptorPb, []int{11} }

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

func (m *AdminResponse) GetChangePeer() *ChangePeerResponse {
	if m != nil {
		return m.ChangePeer
	}
	return nil
}

func (m *AdminResponse) GetSplit() *SplitResponse {
	if m != nil {
		return m.Split
	}
	return nil
}

func (m *AdminResponse) GetTransferLeader() *TransferLeaderResponse {
	if m != nil {
		return m.TransferLeader
	}
	return nil
}

func (m *AdminResponse) GetCompactLog() *CompactLogResponse {
	if m != nil {
		return m.CompactLog
	}
	return nil
}

type ChangePeerRequest struct {
	ChangeType       raftpb.ConfChangeType `protobuf:"varint,1,opt,name=changeType,enum=raftpb.ConfChangeType" json:"changeType"`
	Peer             meta.Peer             `protobuf:"bytes,2,opt,name=peer" json:"peer"`
	XXX_unrecognized []byte                `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 fileDescriptorPb, []int{12} }

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

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

type ChangePeerResponse struct {
	DB               meta.VectorDB `protobuf:"bytes,1,opt,name=db" json:"db"`
	XXX_unrecognized []byte        `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 fileDescriptorPb, []int{13} }

func (m *ChangePeerResponse) GetDB() meta.VectorDB {
	if m != nil {
		return m.DB
	}
	return meta.VectorDB{}
}

type SplitRequest struct {
	// We split the vectordb into two, first uses the origin
	// parent db id, and the second uses the newID.
	// We must guarantee that the newID is global unique.
	NewID uint64 `protobuf:"varint,1,opt,name=newID" json:"newID"`
	// The peer ids for the new split vectordb.
	NewPeerIDs []uint64 `protobuf:"varint,2,rep,name=newPeerIDs" json:"newPeerIDs,omitempty"`
	// The committedOffset last committed offset in mq
	CommittedOffset  int64  `protobuf:"varint,3,opt,name=committedOffset" json:"committedOffset"`
	CommittedIndex   int64  `protobuf:"varint,4,opt,name=committedIndex" json:"committedIndex"`
	XXX_unrecognized []byte `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 fileDescriptorPb, []int{14} }

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

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

func (m *SplitRequest) GetCommittedOffset() int64 {
	if m != nil {
		return m.CommittedOffset
	}
	return 0
}

func (m *SplitRequest) GetCommittedIndex() int64 {
	if m != nil {
		return m.CommittedIndex
	}
	return 0
}

type SplitResponse struct {
	OldDB            meta.VectorDB `protobuf:"bytes,1,opt,name=oldDB" json:"oldDB"`
	NewDB            meta.VectorDB `protobuf:"bytes,2,opt,name=newDB" json:"newDB"`
	XXX_unrecognized []byte        `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 fileDescriptorPb, []int{15} }

func (m *SplitResponse) GetOldDB() meta.VectorDB {
	if m != nil {
		return m.OldDB
	}
	return meta.VectorDB{}
}

func (m *SplitResponse) GetNewDB() meta.VectorDB {
	if m != nil {
		return m.NewDB
	}
	return meta.VectorDB{}
}

type TransferLeaderRequest struct {
	Peer             meta.Peer `protobuf:"bytes,1,opt,name=peer" json:"peer"`
	XXX_unrecognized []byte    `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 fileDescriptorPb, []int{16} }

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

type TransferLeaderResponse struct {
	XXX_unrecognized []byte `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 fileDescriptorPb, []int{17} }

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

func (m *CompactLogRequest) Reset()                    { *m = CompactLogRequest{} }
func (m *CompactLogRequest) String() string            { return proto.CompactTextString(m) }
func (*CompactLogRequest) ProtoMessage()               {}
func (*CompactLogRequest) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{18} }

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

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

type CompactLogResponse struct {
	XXX_unrecognized []byte `json:"-"`
}

func (m *CompactLogResponse) Reset()                    { *m = CompactLogResponse{} }
func (m *CompactLogResponse) String() string            { return proto.CompactTextString(m) }
func (*CompactLogResponse) ProtoMessage()               {}
func (*CompactLogResponse) Descriptor() ([]byte, []int) { return fileDescriptorPb, []int{19} }

func init() {
	proto.RegisterType((*DBLocalState)(nil), "raft.DBLocalState")
	proto.RegisterType((*RaftLocalState)(nil), "raft.RaftLocalState")
	proto.RegisterType((*RaftApplyState)(nil), "raft.RaftApplyState")
	proto.RegisterType((*RaftTruncatedState)(nil), "raft.RaftTruncatedState")
	proto.RegisterType((*RaftMessage)(nil), "raft.RaftMessage")
	proto.RegisterType((*SnapshotMessageHeader)(nil), "raft.SnapshotMessageHeader")
	proto.RegisterType((*SnapshotMessage)(nil), "raft.SnapshotMessage")
	proto.RegisterType((*SnapshotChunkMessage)(nil), "raft.SnapshotChunkMessage")
	proto.RegisterType((*RaftRequestHeader)(nil), "raft.RaftRequestHeader")
	proto.RegisterType((*RaftCMDRequest)(nil), "raft.RaftCMDRequest")
	proto.RegisterType((*AdminRequest)(nil), "raft.AdminRequest")
	proto.RegisterType((*AdminResponse)(nil), "raft.AdminResponse")
	proto.RegisterType((*ChangePeerRequest)(nil), "raft.ChangePeerRequest")
	proto.RegisterType((*ChangePeerResponse)(nil), "raft.ChangePeerResponse")
	proto.RegisterType((*SplitRequest)(nil), "raft.SplitRequest")
	proto.RegisterType((*SplitResponse)(nil), "raft.SplitResponse")
	proto.RegisterType((*TransferLeaderRequest)(nil), "raft.TransferLeaderRequest")
	proto.RegisterType((*TransferLeaderResponse)(nil), "raft.TransferLeaderResponse")
	proto.RegisterType((*CompactLogRequest)(nil), "raft.CompactLogRequest")
	proto.RegisterType((*CompactLogResponse)(nil), "raft.CompactLogResponse")
	proto.RegisterEnum("raft.PeerState", PeerState_name, PeerState_value)
	proto.RegisterEnum("raft.AdminCmdType", AdminCmdType_name, AdminCmdType_value)
}
func (m *DBLocalState) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DBLocalState) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.State))
	dAtA[i] = 0x12
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.DB.Size()))
	n1, err := m.DB.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *RaftLocalState) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.HardState.Size()))
	n2, err := m.HardState.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	dAtA[i] = 0x10
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.LastIndex))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *RaftApplyState) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.AppliedIndex))
	dAtA[i] = 0x12
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.TruncatedState.Size()))
	n3, err := m.TruncatedState.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	dAtA[i] = 0x18
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CommittedOffset))
	dAtA[i] = 0x20
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CommittedIndex))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *RaftTruncatedState) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Index))
	dAtA[i] = 0x10
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Term))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *RaftMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.ID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.From.Size()))
	n4, err := m.From.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n4
	dAtA[i] = 0x1a
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.To.Size()))
	n5, err := m.To.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	dAtA[i] = 0x22
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Epoch.Size()))
	n6, err := m.Epoch.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	dAtA[i] = 0x28
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Start))
	dAtA[i] = 0x30
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.DBState))
	dAtA[i] = 0x38
	i++
	if m.Tombstone {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x42
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Message.Size()))
	n7, err := m.Message.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SnapshotMessageHeader) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.DB.Size()))
	n8, err := m.DB.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n8
	dAtA[i] = 0x12
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.From.Size()))
	n9, err := m.From.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n9
	dAtA[i] = 0x1a
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.To.Size()))
	n10, err := m.To.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n10
	dAtA[i] = 0x20
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Term))
	dAtA[i] = 0x28
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Index))
	dAtA[i] = 0x30
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Seq))
	dAtA[i] = 0x38
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CommittedOffset))
	dAtA[i] = 0x40
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CommittedIndex))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SnapshotMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Header.Size()))
	n11, err := m.Header.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n11
	if m.Chunk != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.Chunk.Size()))
		n12, err := m.Chunk.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SnapshotChunkMessage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintPb(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	dAtA[i] = 0x10
	i++
	if m.First {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x18
	i++
	if m.Last {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x20
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.FileSize))
	dAtA[i] = 0x28
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CheckSum))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *RaftRequestHeader) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.ID))
	if m.UUID != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintPb(dAtA, i, uint64(len(m.UUID)))
		i += copy(dAtA[i:], m.UUID)
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Peer.Size()))
	n13, err := m.Peer.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n13
	dAtA[i] = 0x22
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Epoch.Size()))
	n14, err := m.Epoch.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n14
	dAtA[i] = 0x28
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Term))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *RaftCMDRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Header.Size()))
	n15, err := m.Header.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n15
	if len(m.Inserts) > 0 {
		for _, msg := range m.Inserts {
			dAtA[i] = 0x12
			i++
			i = encodeVarintPb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Updates) > 0 {
		for _, msg := range m.Updates {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintPb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Admin != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.Admin.Size()))
		n16, err := m.Admin.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *AdminRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Type))
	if m.ChangePeer != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.ChangePeer.Size()))
		n17, err := m.ChangePeer.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if m.Split != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.Split.Size()))
		n18, err := m.Split.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if m.TransferLeader != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.TransferLeader.Size()))
		n19, err := m.TransferLeader.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	if m.CompactLog != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.CompactLog.Size()))
		n20, err := m.CompactLog.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *AdminResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Type))
	if m.ChangePeer != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.ChangePeer.Size()))
		n21, err := m.ChangePeer.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	if m.Split != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.Split.Size()))
		n22, err := m.Split.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n22
	}
	if m.TransferLeader != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.TransferLeader.Size()))
		n23, err := m.TransferLeader.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n23
	}
	if m.CompactLog != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintPb(dAtA, i, uint64(m.CompactLog.Size()))
		n24, err := m.CompactLog.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n24
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ChangePeerRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.ChangeType))
	dAtA[i] = 0x12
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Peer.Size()))
	n25, err := m.Peer.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n25
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *ChangePeerResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.DB.Size()))
	n26, err := m.DB.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n26
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SplitRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.NewID))
	if len(m.NewPeerIDs) > 0 {
		for _, num := range m.NewPeerIDs {
			dAtA[i] = 0x10
			i++
			i = encodeVarintPb(dAtA, i, uint64(num))
		}
	}
	dAtA[i] = 0x18
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CommittedOffset))
	dAtA[i] = 0x20
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CommittedIndex))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *SplitResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.OldDB.Size()))
	n27, err := m.OldDB.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n27
	dAtA[i] = 0x12
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.NewDB.Size()))
	n28, err := m.NewDB.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n28
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *TransferLeaderRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.Peer.Size()))
	n29, err := m.Peer.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n29
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

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

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

func (m *CompactLogRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CompactIndex))
	dAtA[i] = 0x10
	i++
	i = encodeVarintPb(dAtA, i, uint64(m.CompactTerm))
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

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

func (m *CompactLogResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintPb(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *DBLocalState) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovPb(uint64(m.State))
	l = m.DB.Size()
	n += 1 + l + sovPb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftLocalState) Size() (n int) {
	var l int
	_ = l
	l = m.HardState.Size()
	n += 1 + l + sovPb(uint64(l))
	n += 1 + sovPb(uint64(m.LastIndex))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftApplyState) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovPb(uint64(m.AppliedIndex))
	l = m.TruncatedState.Size()
	n += 1 + l + sovPb(uint64(l))
	n += 1 + sovPb(uint64(m.CommittedOffset))
	n += 1 + sovPb(uint64(m.CommittedIndex))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftTruncatedState) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovPb(uint64(m.Index))
	n += 1 + sovPb(uint64(m.Term))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftMessage) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovPb(uint64(m.ID))
	l = m.From.Size()
	n += 1 + l + sovPb(uint64(l))
	l = m.To.Size()
	n += 1 + l + sovPb(uint64(l))
	l = m.Epoch.Size()
	n += 1 + l + sovPb(uint64(l))
	n += 1 + sovPb(uint64(m.Start))
	n += 1 + sovPb(uint64(m.DBState))
	n += 2
	l = m.Message.Size()
	n += 1 + l + sovPb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SnapshotMessageHeader) Size() (n int) {
	var l int
	_ = l
	l = m.DB.Size()
	n += 1 + l + sovPb(uint64(l))
	l = m.From.Size()
	n += 1 + l + sovPb(uint64(l))
	l = m.To.Size()
	n += 1 + l + sovPb(uint64(l))
	n += 1 + sovPb(uint64(m.Term))
	n += 1 + sovPb(uint64(m.Index))
	n += 1 + sovPb(uint64(m.Seq))
	n += 1 + sovPb(uint64(m.CommittedOffset))
	n += 1 + sovPb(uint64(m.CommittedIndex))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SnapshotMessage) Size() (n int) {
	var l int
	_ = l
	l = m.Header.Size()
	n += 1 + l + sovPb(uint64(l))
	if m.Chunk != nil {
		l = m.Chunk.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SnapshotChunkMessage) Size() (n int) {
	var l int
	_ = l
	if m.Data != nil {
		l = len(m.Data)
		n += 1 + l + sovPb(uint64(l))
	}
	n += 2
	n += 2
	n += 1 + sovPb(uint64(m.FileSize))
	n += 1 + sovPb(uint64(m.CheckSum))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RaftRequestHeader) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovPb(uint64(m.ID))
	if m.UUID != nil {
		l = len(m.UUID)
		n += 1 + l + sovPb(uint64(l))
	}
	l = m.Peer.Size()
	n += 1 + l + sovPb(uint64(l))
	l = m.Epoch.Size()
	n += 1 + l + sovPb(uint64(l))
	n += 1 + sovPb(uint64(m.Term))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *AdminRequest) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovPb(uint64(m.Type))
	if m.ChangePeer != nil {
		l = m.ChangePeer.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.Split != nil {
		l = m.Split.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.TransferLeader != nil {
		l = m.TransferLeader.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.CompactLog != nil {
		l = m.CompactLog.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AdminResponse) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovPb(uint64(m.Type))
	if m.ChangePeer != nil {
		l = m.ChangePeer.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.Split != nil {
		l = m.Split.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.TransferLeader != nil {
		l = m.TransferLeader.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.CompactLog != nil {
		l = m.CompactLog.Size()
		n += 1 + l + sovPb(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

func (m *SplitResponse) Size() (n int) {
	var l int
	_ = l
	l = m.OldDB.Size()
	n += 1 + l + sovPb(uint64(l))
	l = m.NewDB.Size()
	n += 1 + l + sovPb(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

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

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

func sovPb(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozPb(x uint64) (n int) {
	return sovPb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DBLocalState) 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 ErrIntOverflowPb
			}
			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: DBLocalState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DBLocalState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= (PeerState(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DB", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *RaftLocalState) 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 ErrIntOverflowPb
			}
			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: RaftLocalState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftLocalState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HardState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.HardState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastIndex", wireType)
			}
			m.LastIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastIndex |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *RaftApplyState) 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 ErrIntOverflowPb
			}
			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: RaftApplyState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftApplyState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppliedIndex", wireType)
			}
			m.AppliedIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AppliedIndex |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TruncatedState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TruncatedState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedOffset", wireType)
			}
			m.CommittedOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedOffset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedIndex", wireType)
			}
			m.CommittedIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedIndex |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *RaftTruncatedState) 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 ErrIntOverflowPb
			}
			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: RaftTruncatedState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftTruncatedState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowPb
				}
				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 := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *RaftMessage) 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 ErrIntOverflowPb
			}
			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: RaftMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.From.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Epoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			m.Start = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Start |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DBState", wireType)
			}
			m.DBState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DBState |= (meta.DBState(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tombstone", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Tombstone = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *SnapshotMessageHeader) 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 ErrIntOverflowPb
			}
			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: SnapshotMessageHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SnapshotMessageHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DB", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.From.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Term |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)
			}
			m.Seq = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedOffset", wireType)
			}
			m.CommittedOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedOffset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedIndex", wireType)
			}
			m.CommittedIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedIndex |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *SnapshotMessage) 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 ErrIntOverflowPb
			}
			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: SnapshotMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SnapshotMessage: 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 ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			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 Chunk", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Chunk == nil {
				m.Chunk = &SnapshotChunkMessage{}
			}
			if err := m.Chunk.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *SnapshotChunkMessage) 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 ErrIntOverflowPb
			}
			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: SnapshotChunkMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SnapshotChunkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field First", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.First = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Last", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Last = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileSize", wireType)
			}
			m.FileSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FileSize |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CheckSum", wireType)
			}
			m.CheckSum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CheckSum |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *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 ErrIntOverflowPb
			}
			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 ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + byteLen
			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 != 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 ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Peer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Epoch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowPb
				}
				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 := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			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 Inserts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Inserts = append(m.Inserts, &rpc.InsertRequest{})
			if err := m.Inserts[len(m.Inserts)-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 Updates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Updates = append(m.Updates, &rpc.UpdateRequest{})
			if err := m.Updates[len(m.Updates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Admin == nil {
				m.Admin = &AdminRequest{}
			}
			if err := m.Admin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 ErrIntOverflowPb
				}
				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 ChangePeer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangePeer == nil {
				m.ChangePeer = &ChangePeerRequest{}
			}
			if err := m.ChangePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Split", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Split == nil {
				m.Split = &SplitRequest{}
			}
			if err := m.Split.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransferLeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TransferLeader == nil {
				m.TransferLeader = &TransferLeaderRequest{}
			}
			if err := m.TransferLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompactLog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CompactLog == nil {
				m.CompactLog = &CompactLogRequest{}
			}
			if err := m.CompactLog.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 ErrIntOverflowPb
				}
				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 ChangePeer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangePeer == nil {
				m.ChangePeer = &ChangePeerResponse{}
			}
			if err := m.ChangePeer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Split", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Split == nil {
				m.Split = &SplitResponse{}
			}
			if err := m.Split.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransferLeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TransferLeader == nil {
				m.TransferLeader = &TransferLeaderResponse{}
			}
			if err := m.TransferLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompactLog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CompactLog == nil {
				m.CompactLog = &CompactLogResponse{}
			}
			if err := m.CompactLog.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChangeType |= (raftpb.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 ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			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 := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 DB", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.DB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewID", wireType)
			}
			m.NewID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NewID |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowPb
					}
					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 ErrIntOverflowPb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthPb
				}
				postIndex := iNdEx + packedLen
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowPb
						}
						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 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedOffset", wireType)
			}
			m.CommittedOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedOffset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommittedIndex", wireType)
			}
			m.CommittedIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CommittedIndex |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 OldDB", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OldDB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewDB", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NewDB.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 ErrIntOverflowPb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPb
			}
			postIndex := iNdEx + msglen
			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 := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 ErrIntOverflowPb
			}
			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 := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *CompactLogRequest) 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 ErrIntOverflowPb
			}
			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: CompactLogRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompactLogRequest: 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 ErrIntOverflowPb
				}
				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 ErrIntOverflowPb
				}
				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 := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 *CompactLogResponse) 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 ErrIntOverflowPb
			}
			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: CompactLogResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CompactLogResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipPb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPb
			}
			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 skipPb(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, ErrIntOverflowPb
			}
			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, ErrIntOverflowPb
				}
				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, ErrIntOverflowPb
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthPb
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowPb
					}
					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 := skipPb(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthPb = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowPb   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("pb.proto", fileDescriptorPb) }

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