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

/*
	Package eraftpb is a generated protocol buffer package.

	It is generated from these files:
		eraftpb.proto

	It has these top-level messages:
		Entry
		SnapshotMetadata
		Snapshot
		Message
		HardState
		ConfState
		ConfChange
*/
package eraftpb

import (
	"fmt"
	"io"
	"math"

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

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

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

type EntryType int32

const (
	EntryType_EntryNormal     EntryType = 0
	EntryType_EntryConfChange EntryType = 1
)

var EntryType_name = map[int32]string{
	0: "EntryNormal",
	1: "EntryConfChange",
}
var EntryType_value = map[string]int32{
	"EntryNormal":     0,
	"EntryConfChange": 1,
}

func (x EntryType) String() string {
	return proto.EnumName(EntryType_name, int32(x))
}
func (EntryType) EnumDescriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{0} }

type MessageType int32

const (
	MessageType_MsgHup                    MessageType = 0
	MessageType_MsgBeat                   MessageType = 1
	MessageType_MsgPropose                MessageType = 2
	MessageType_MsgAppend                 MessageType = 3
	MessageType_MsgAppendResponse         MessageType = 4
	MessageType_MsgRequestVote            MessageType = 5
	MessageType_MsgRequestVoteResponse    MessageType = 6
	MessageType_MsgSnapshot               MessageType = 7
	MessageType_MsgHeartbeat              MessageType = 8
	MessageType_MsgHeartbeatResponse      MessageType = 9
	MessageType_MsgUnreachable            MessageType = 10
	MessageType_MsgSnapStatus             MessageType = 11
	MessageType_MsgCheckQuorum            MessageType = 12
	MessageType_MsgTransferLeader         MessageType = 13
	MessageType_MsgTimeoutNow             MessageType = 14
	MessageType_MsgReadIndex              MessageType = 15
	MessageType_MsgReadIndexResp          MessageType = 16
	MessageType_MsgRequestPreVote         MessageType = 17
	MessageType_MsgRequestPreVoteResponse MessageType = 18
)

var MessageType_name = map[int32]string{
	0:  "MsgHup",
	1:  "MsgBeat",
	2:  "MsgPropose",
	3:  "MsgAppend",
	4:  "MsgAppendResponse",
	5:  "MsgRequestVote",
	6:  "MsgRequestVoteResponse",
	7:  "MsgSnapshot",
	8:  "MsgHeartbeat",
	9:  "MsgHeartbeatResponse",
	10: "MsgUnreachable",
	11: "MsgSnapStatus",
	12: "MsgCheckQuorum",
	13: "MsgTransferLeader",
	14: "MsgTimeoutNow",
	15: "MsgReadIndex",
	16: "MsgReadIndexResp",
	17: "MsgRequestPreVote",
	18: "MsgRequestPreVoteResponse",
}
var MessageType_value = map[string]int32{
	"MsgHup":                    0,
	"MsgBeat":                   1,
	"MsgPropose":                2,
	"MsgAppend":                 3,
	"MsgAppendResponse":         4,
	"MsgRequestVote":            5,
	"MsgRequestVoteResponse":    6,
	"MsgSnapshot":               7,
	"MsgHeartbeat":              8,
	"MsgHeartbeatResponse":      9,
	"MsgUnreachable":            10,
	"MsgSnapStatus":             11,
	"MsgCheckQuorum":            12,
	"MsgTransferLeader":         13,
	"MsgTimeoutNow":             14,
	"MsgReadIndex":              15,
	"MsgReadIndexResp":          16,
	"MsgRequestPreVote":         17,
	"MsgRequestPreVoteResponse": 18,
}

func (x MessageType) String() string {
	return proto.EnumName(MessageType_name, int32(x))
}
func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{1} }

type ConfChangeType int32

const (
	ConfChangeType_AddNode        ConfChangeType = 0
	ConfChangeType_RemoveNode     ConfChangeType = 1
	ConfChangeType_AddLearnerNode ConfChangeType = 2
)

var ConfChangeType_name = map[int32]string{
	0: "AddNode",
	1: "RemoveNode",
	2: "AddLearnerNode",
}
var ConfChangeType_value = map[string]int32{
	"AddNode":        0,
	"RemoveNode":     1,
	"AddLearnerNode": 2,
}

func (x ConfChangeType) String() string {
	return proto.EnumName(ConfChangeType_name, int32(x))
}
func (ConfChangeType) EnumDescriptor() ([]byte, []int) { return fileDescriptorEraftpb, []int{2} }

type Entry struct {
	EntryType EntryType `protobuf:"varint,1,opt,name=entry_type,json=entryType,proto3,enum=eraftpb.EntryType" json:"entry_type,omitempty"`
	Term      uint64    `protobuf:"varint,2,opt,name=term,proto3" json:"term,omitempty"`
	Index     uint64    `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
	Data      []byte    `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
	SyncLog   bool      `protobuf:"varint,5,opt,name=sync_log,json=syncLog,proto3" json:"sync_log,omitempty"`
}

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

func (m *Entry) GetEntryType() EntryType {
	if m != nil {
		return m.EntryType
	}
	return EntryType_EntryNormal
}

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

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

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

func (m *Entry) GetSyncLog() bool {
	if m != nil {
		return m.SyncLog
	}
	return false
}

type SnapshotMetadata struct {
	ConfState *ConfState `protobuf:"bytes,1,opt,name=conf_state,json=confState" json:"conf_state,omitempty"`
	Index     uint64     `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	Term      uint64     `protobuf:"varint,3,opt,name=term,proto3" json:"term,omitempty"`
}

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

func (m *SnapshotMetadata) GetConfState() *ConfState {
	if m != nil {
		return m.ConfState
	}
	return nil
}

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

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

type Snapshot struct {
	Data     []byte            `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	Metadata *SnapshotMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata,omitempty"`
}

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

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

func (m *Snapshot) GetMetadata() *SnapshotMetadata {
	if m != nil {
		return m.Metadata
	}
	return nil
}

type Message struct {
	MsgType    MessageType `protobuf:"varint,1,opt,name=msg_type,json=msgType,proto3,enum=eraftpb.MessageType" json:"msg_type,omitempty"`
	To         uint64      `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"`
	From       uint64      `protobuf:"varint,3,opt,name=from,proto3" json:"from,omitempty"`
	Term       uint64      `protobuf:"varint,4,opt,name=term,proto3" json:"term,omitempty"`
	LogTerm    uint64      `protobuf:"varint,5,opt,name=log_term,json=logTerm,proto3" json:"log_term,omitempty"`
	Index      uint64      `protobuf:"varint,6,opt,name=index,proto3" json:"index,omitempty"`
	Entries    []*Entry    `protobuf:"bytes,7,rep,name=entries" json:"entries,omitempty"`
	Commit     uint64      `protobuf:"varint,8,opt,name=commit,proto3" json:"commit,omitempty"`
	Snapshot   *Snapshot   `protobuf:"bytes,9,opt,name=snapshot" json:"snapshot,omitempty"`
	Reject     bool        `protobuf:"varint,10,opt,name=reject,proto3" json:"reject,omitempty"`
	RejectHint uint64      `protobuf:"varint,11,opt,name=reject_hint,json=rejectHint,proto3" json:"reject_hint,omitempty"`
	Context    []byte      `protobuf:"bytes,12,opt,name=context,proto3" json:"context,omitempty"`
}

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

func (m *Message) GetMsgType() MessageType {
	if m != nil {
		return m.MsgType
	}
	return MessageType_MsgHup
}

func (m *Message) GetTo() uint64 {
	if m != nil {
		return m.To
	}
	return 0
}

func (m *Message) GetFrom() uint64 {
	if m != nil {
		return m.From
	}
	return 0
}

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

func (m *Message) GetLogTerm() uint64 {
	if m != nil {
		return m.LogTerm
	}
	return 0
}

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

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

func (m *Message) GetCommit() uint64 {
	if m != nil {
		return m.Commit
	}
	return 0
}

func (m *Message) GetSnapshot() *Snapshot {
	if m != nil {
		return m.Snapshot
	}
	return nil
}

func (m *Message) GetReject() bool {
	if m != nil {
		return m.Reject
	}
	return false
}

func (m *Message) GetRejectHint() uint64 {
	if m != nil {
		return m.RejectHint
	}
	return 0
}

func (m *Message) GetContext() []byte {
	if m != nil {
		return m.Context
	}
	return nil
}

type HardState struct {
	Term   uint64 `protobuf:"varint,1,opt,name=term,proto3" json:"term,omitempty"`
	Vote   uint64 `protobuf:"varint,2,opt,name=vote,proto3" json:"vote,omitempty"`
	Commit uint64 `protobuf:"varint,3,opt,name=commit,proto3" json:"commit,omitempty"`
}

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

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

func (m *HardState) GetVote() uint64 {
	if m != nil {
		return m.Vote
	}
	return 0
}

func (m *HardState) GetCommit() uint64 {
	if m != nil {
		return m.Commit
	}
	return 0
}

type ConfState struct {
	Nodes    []uint64 `protobuf:"varint,1,rep,packed,name=nodes" json:"nodes,omitempty"`
	Learners []uint64 `protobuf:"varint,2,rep,packed,name=learners" json:"learners,omitempty"`
}

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

func (m *ConfState) GetNodes() []uint64 {
	if m != nil {
		return m.Nodes
	}
	return nil
}

func (m *ConfState) GetLearners() []uint64 {
	if m != nil {
		return m.Learners
	}
	return nil
}

type ConfChange struct {
	Id         uint64         `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	ChangeType ConfChangeType `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3,enum=eraftpb.ConfChangeType" json:"change_type,omitempty"`
	NodeId     uint64         `protobuf:"varint,3,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
	Context    []byte         `protobuf:"bytes,4,opt,name=context,proto3" json:"context,omitempty"`
}

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

func (m *ConfChange) GetId() uint64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (m *ConfChange) GetChangeType() ConfChangeType {
	if m != nil {
		return m.ChangeType
	}
	return ConfChangeType_AddNode
}

func (m *ConfChange) GetNodeId() uint64 {
	if m != nil {
		return m.NodeId
	}
	return 0
}

func (m *ConfChange) GetContext() []byte {
	if m != nil {
		return m.Context
	}
	return nil
}

func init() {
	proto.RegisterType((*Entry)(nil), "eraftpb.Entry")
	proto.RegisterType((*SnapshotMetadata)(nil), "eraftpb.SnapshotMetadata")
	proto.RegisterType((*Snapshot)(nil), "eraftpb.Snapshot")
	proto.RegisterType((*Message)(nil), "eraftpb.Message")
	proto.RegisterType((*HardState)(nil), "eraftpb.HardState")
	proto.RegisterType((*ConfState)(nil), "eraftpb.ConfState")
	proto.RegisterType((*ConfChange)(nil), "eraftpb.ConfChange")
	proto.RegisterEnum("eraftpb.EntryType", EntryType_name, EntryType_value)
	proto.RegisterEnum("eraftpb.MessageType", MessageType_name, MessageType_value)
	proto.RegisterEnum("eraftpb.ConfChangeType", ConfChangeType_name, ConfChangeType_value)
}
func (m *Entry) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Entry) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.EntryType != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.EntryType))
	}
	if m.Term != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Term))
	}
	if m.Index != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Index))
	}
	if len(m.Data) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Data)))
		i += copy(dAtA[i:], m.Data)
	}
	if m.SyncLog {
		dAtA[i] = 0x28
		i++
		if m.SyncLog {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *SnapshotMetadata) 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 *SnapshotMetadata) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ConfState != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.ConfState.Size()))
		n1, err := m.ConfState.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.Index != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Index))
	}
	if m.Term != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Term))
	}
	return i, nil
}

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

func (m *Message) 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 *Message) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.MsgType != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.MsgType))
	}
	if m.To != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.To))
	}
	if m.From != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.From))
	}
	if m.Term != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Term))
	}
	if m.LogTerm != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.LogTerm))
	}
	if m.Index != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Index))
	}
	if len(m.Entries) > 0 {
		for _, msg := range m.Entries {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintEraftpb(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Commit != 0 {
		dAtA[i] = 0x40
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Commit))
	}
	if m.Snapshot != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Snapshot.Size()))
		n3, err := m.Snapshot.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Reject {
		dAtA[i] = 0x50
		i++
		if m.Reject {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.RejectHint != 0 {
		dAtA[i] = 0x58
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.RejectHint))
	}
	if len(m.Context) > 0 {
		dAtA[i] = 0x62
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context)))
		i += copy(dAtA[i:], m.Context)
	}
	return i, nil
}

func (m *HardState) 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 *HardState) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Term != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Term))
	}
	if m.Vote != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Vote))
	}
	if m.Commit != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Commit))
	}
	return i, nil
}

func (m *ConfState) 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 *ConfState) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Nodes) > 0 {
		dAtA5 := make([]byte, len(m.Nodes)*10)
		var j4 int
		for _, num := range m.Nodes {
			for num >= 1<<7 {
				dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j4++
			}
			dAtA5[j4] = uint8(num)
			j4++
		}
		dAtA[i] = 0xa
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(j4))
		i += copy(dAtA[i:], dAtA5[:j4])
	}
	if len(m.Learners) > 0 {
		dAtA7 := make([]byte, len(m.Learners)*10)
		var j6 int
		for _, num := range m.Learners {
			for num >= 1<<7 {
				dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j6++
			}
			dAtA7[j6] = uint8(num)
			j6++
		}
		dAtA[i] = 0x12
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(j6))
		i += copy(dAtA[i:], dAtA7[:j6])
	}
	return i, nil
}

func (m *ConfChange) 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 *ConfChange) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.Id))
	}
	if m.ChangeType != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.ChangeType))
	}
	if m.NodeId != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(m.NodeId))
	}
	if len(m.Context) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintEraftpb(dAtA, i, uint64(len(m.Context)))
		i += copy(dAtA[i:], m.Context)
	}
	return i, nil
}

func encodeFixed64Eraftpb(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Eraftpb(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintEraftpb(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 *Entry) Size() (n int) {
	var l int
	_ = l
	if m.EntryType != 0 {
		n += 1 + sovEraftpb(uint64(m.EntryType))
	}
	if m.Term != 0 {
		n += 1 + sovEraftpb(uint64(m.Term))
	}
	if m.Index != 0 {
		n += 1 + sovEraftpb(uint64(m.Index))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovEraftpb(uint64(l))
	}
	if m.SyncLog {
		n += 2
	}
	return n
}

func (m *SnapshotMetadata) Size() (n int) {
	var l int
	_ = l
	if m.ConfState != nil {
		l = m.ConfState.Size()
		n += 1 + l + sovEraftpb(uint64(l))
	}
	if m.Index != 0 {
		n += 1 + sovEraftpb(uint64(m.Index))
	}
	if m.Term != 0 {
		n += 1 + sovEraftpb(uint64(m.Term))
	}
	return n
}

func (m *Snapshot) Size() (n int) {
	var l int
	_ = l
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovEraftpb(uint64(l))
	}
	if m.Metadata != nil {
		l = m.Metadata.Size()
		n += 1 + l + sovEraftpb(uint64(l))
	}
	return n
}

func (m *Message) Size() (n int) {
	var l int
	_ = l
	if m.MsgType != 0 {
		n += 1 + sovEraftpb(uint64(m.MsgType))
	}
	if m.To != 0 {
		n += 1 + sovEraftpb(uint64(m.To))
	}
	if m.From != 0 {
		n += 1 + sovEraftpb(uint64(m.From))
	}
	if m.Term != 0 {
		n += 1 + sovEraftpb(uint64(m.Term))
	}
	if m.LogTerm != 0 {
		n += 1 + sovEraftpb(uint64(m.LogTerm))
	}
	if m.Index != 0 {
		n += 1 + sovEraftpb(uint64(m.Index))
	}
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovEraftpb(uint64(l))
		}
	}
	if m.Commit != 0 {
		n += 1 + sovEraftpb(uint64(m.Commit))
	}
	if m.Snapshot != nil {
		l = m.Snapshot.Size()
		n += 1 + l + sovEraftpb(uint64(l))
	}
	if m.Reject {
		n += 2
	}
	if m.RejectHint != 0 {
		n += 1 + sovEraftpb(uint64(m.RejectHint))
	}
	l = len(m.Context)
	if l > 0 {
		n += 1 + l + sovEraftpb(uint64(l))
	}
	return n
}

func (m *HardState) Size() (n int) {
	var l int
	_ = l
	if m.Term != 0 {
		n += 1 + sovEraftpb(uint64(m.Term))
	}
	if m.Vote != 0 {
		n += 1 + sovEraftpb(uint64(m.Vote))
	}
	if m.Commit != 0 {
		n += 1 + sovEraftpb(uint64(m.Commit))
	}
	return n
}

func (m *ConfState) Size() (n int) {
	var l int
	_ = l
	if len(m.Nodes) > 0 {
		l = 0
		for _, e := range m.Nodes {
			l += sovEraftpb(uint64(e))
		}
		n += 1 + sovEraftpb(uint64(l)) + l
	}
	if len(m.Learners) > 0 {
		l = 0
		for _, e := range m.Learners {
			l += sovEraftpb(uint64(e))
		}
		n += 1 + sovEraftpb(uint64(l)) + l
	}
	return n
}

func (m *ConfChange) Size() (n int) {
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovEraftpb(uint64(m.Id))
	}
	if m.ChangeType != 0 {
		n += 1 + sovEraftpb(uint64(m.ChangeType))
	}
	if m.NodeId != 0 {
		n += 1 + sovEraftpb(uint64(m.NodeId))
	}
	l = len(m.Context)
	if l > 0 {
		n += 1 + l + sovEraftpb(uint64(l))
	}
	return n
}

func sovEraftpb(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozEraftpb(x uint64) (n int) {
	return sovEraftpb(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Entry) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowEraftpb
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Entry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryType", wireType)
			}
			m.EntryType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EntryType |= (EntryType(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 ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Term |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			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 ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEraftpb
			}
			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 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SyncLog", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SyncLog = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEraftpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEraftpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SnapshotMetadata) 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 ErrIntOverflowEraftpb
			}
			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: SnapshotMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SnapshotMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEraftpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConfState == nil {
				m.ConfState = &ConfState{}
			}
			if err := m.ConfState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowEraftpb
				}
				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 := skipEraftpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEraftpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Snapshot) 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 ErrIntOverflowEraftpb
			}
			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: Snapshot: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Snapshot: 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 ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEraftpb
			}
			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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEraftpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Metadata == nil {
				m.Metadata = &SnapshotMetadata{}
			}
			if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEraftpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEraftpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Message) 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 ErrIntOverflowEraftpb
			}
			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: Message: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgType", wireType)
			}
			m.MsgType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgType |= (MessageType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			m.To = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.To |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			m.From = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.From |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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 ErrIntOverflowEraftpb
				}
				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 LogTerm", wireType)
			}
			m.LogTerm = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogTerm |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEraftpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, &Entry{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
			}
			m.Commit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Commit |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEraftpb
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Snapshot == nil {
				m.Snapshot = &Snapshot{}
			}
			if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reject", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Reject = bool(v != 0)
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RejectHint", wireType)
			}
			m.RejectHint = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RejectHint |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEraftpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...)
			if m.Context == nil {
				m.Context = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEraftpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEraftpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfState) 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 ErrIntOverflowEraftpb
			}
			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: ConfState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEraftpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEraftpb
				}
				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 ErrIntOverflowEraftpb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Nodes = append(m.Nodes, v)
				}
			} else if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEraftpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Nodes = append(m.Nodes, v)
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
		case 2:
			if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEraftpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= (int(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthEraftpb
				}
				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 ErrIntOverflowEraftpb
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Learners = append(m.Learners, v)
				}
			} else if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowEraftpb
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Learners = append(m.Learners, v)
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Learners", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEraftpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEraftpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfChange) 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 ErrIntOverflowEraftpb
			}
			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: ConfChange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfChange: 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 ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChangeType |= (ConfChangeType(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
			}
			m.NodeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeId |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEraftpb
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEraftpb
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...)
			if m.Context == nil {
				m.Context = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEraftpb(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEraftpb
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

func init() { proto.RegisterFile("eraftpb.proto", fileDescriptorEraftpb) }

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