traft.pb.go

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

package traft

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// Cmd defines the action a log record does
type Cmd struct {
	Op  string `protobuf:"bytes,10,opt,name=Op,proto3" json:"Op,omitempty"`
	Key string `protobuf:"bytes,20,opt,name=Key,proto3" json:"Key,omitempty"`
	// Types that are valid to be assigned to Value:
	//	*Cmd_VStr
	//	*Cmd_VI64
	//	*Cmd_VClusterConfig
	Value isCmd_Value `protobuf_oneof:"Value"`
}

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

var xxx_messageInfo_Cmd proto.InternalMessageInfo

type isCmd_Value interface {
	isCmd_Value()
	Equal(interface{}) bool
	MarshalTo([]byte) (int, error)
	Size() int
}

type Cmd_VStr struct {
	VStr string `protobuf:"bytes,31,opt,name=VStr,proto3,oneof" json:"VStr,omitempty"`
}
type Cmd_VI64 struct {
	VI64 int64 `protobuf:"varint,32,opt,name=VI64,proto3,oneof" json:"VI64,omitempty"`
}
type Cmd_VClusterConfig struct {
	VClusterConfig *Cluster `protobuf:"bytes,33,opt,name=VClusterConfig,proto3,oneof" json:"VClusterConfig,omitempty"`
}

func (*Cmd_VStr) isCmd_Value()           {}
func (*Cmd_VI64) isCmd_Value()           {}
func (*Cmd_VClusterConfig) isCmd_Value() {}

func (m *Cmd) GetValue() isCmd_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Cmd) GetOp() string {
	if m != nil {
		return m.Op
	}
	return ""
}

func (m *Cmd) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *Cmd) GetVStr() string {
	if x, ok := m.GetValue().(*Cmd_VStr); ok {
		return x.VStr
	}
	return ""
}

func (m *Cmd) GetVI64() int64 {
	if x, ok := m.GetValue().(*Cmd_VI64); ok {
		return x.VI64
	}
	return 0
}

func (m *Cmd) GetVClusterConfig() *Cluster {
	if x, ok := m.GetValue().(*Cmd_VClusterConfig); ok {
		return x.VClusterConfig
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Cmd) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Cmd_VStr)(nil),
		(*Cmd_VI64)(nil),
		(*Cmd_VClusterConfig)(nil),
	}
}

// TailBitmap is a bitmap that has all its leading bits set to `1`.
// Thus it is compressed with an Offset of all-ones position and a trailing
// bitmap.
// It is used to describe LogRecord dependency etc.
//
// The data structure is as the following described:
//
//                      reclaimed
//                      |
//                      |     Offset
//                      |     |
//                      v     v
//                ..... X ... 01010...00111  00...
//   bitIndex:    0123...     ^              ^
//                            |              |
//                            Words[0]       Words[1]
//
type TailBitmap struct {
	Offset   int64    `protobuf:"varint,1,opt,name=Offset,proto3" json:"Offset,omitempty"`
	Words    []uint64 `protobuf:"varint,2,rep,packed,name=Words,proto3" json:"Words,omitempty"`
	Reclamed int64    `protobuf:"varint,3,opt,name=Reclamed,proto3" json:"Reclamed,omitempty"`
}

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

var xxx_messageInfo_TailBitmap proto.InternalMessageInfo

func (m *TailBitmap) GetOffset() int64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *TailBitmap) GetWords() []uint64 {
	if m != nil {
		return m.Words
	}
	return nil
}

func (m *TailBitmap) GetReclamed() int64 {
	if m != nil {
		return m.Reclamed
	}
	return 0
}

// LogRecord is a log record
type LogRecord struct {
	// Which leader initially proposed this log.
	// Author may not be the same with Committer, if Author fails when trying to
	// commit a log record.
	//
	// TODO It seems this field is useless. Because we already have `Accepted`.
	// This is different from the original raft:
	// raft does not have a explicit concept `accepted`, which is essential in
	// paxos.
	// Instead, The `committed` in raft is defined as: leader forwards its
	// own term log to a quorum.
	Author *LeaderId `protobuf:"bytes,1,opt,name=Author,proto3" json:"Author,omitempty"`
	// Log sequence number.
	Seq int64 `protobuf:"varint,10,opt,name=Seq,proto3" json:"Seq,omitempty"`
	// Cmd describes what this log does.
	Cmd *Cmd `protobuf:"bytes,30,opt,name=Cmd,proto3" json:"Cmd,omitempty"`
	// The logs that must be executed before this one.
	// Normally it is the least lsn on a leader that is not purged yet.
	Depends *TailBitmap `protobuf:"bytes,32,opt,name=Depends,proto3" json:"Depends,omitempty"`
	// Overrides describes what previous logs this log record overrides.
	Overrides *TailBitmap `protobuf:"bytes,40,opt,name=Overrides,proto3" json:"Overrides,omitempty"`
}

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

var xxx_messageInfo_LogRecord proto.InternalMessageInfo

func (m *LogRecord) GetAuthor() *LeaderId {
	if m != nil {
		return m.Author
	}
	return nil
}

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

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

func (m *LogRecord) GetDepends() *TailBitmap {
	if m != nil {
		return m.Depends
	}
	return nil
}

func (m *LogRecord) GetOverrides() *TailBitmap {
	if m != nil {
		return m.Overrides
	}
	return nil
}

type LeaderId struct {
	Term int64 `protobuf:"varint,1,opt,name=Term,proto3" json:"Term,omitempty"`
	Id   int64 `protobuf:"varint,2,opt,name=Id,proto3" json:"Id,omitempty"`
}

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

var xxx_messageInfo_LeaderId proto.InternalMessageInfo

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

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

type Node struct {
	// replica id of this replica.
	Id     int64    `protobuf:"varint,3,opt,name=Id,proto3" json:"Id,omitempty"`
	Config *Cluster `protobuf:"bytes,1,opt,name=Config,proto3" json:"Config,omitempty"`
	// From which log seq number we keeps here.
	LogOffset int64        `protobuf:"varint,4,opt,name=LogOffset,proto3" json:"LogOffset,omitempty"`
	Logs      []*LogRecord `protobuf:"bytes,2,rep,name=Logs,proto3" json:"Logs,omitempty"`
	// local view of every replica, including this node too.
	Status map[int64]*ReplicaStatus `protobuf:"bytes,6,rep,name=Status,proto3" json:"Status,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_Node proto.InternalMessageInfo

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

func (m *Node) GetConfig() *Cluster {
	if m != nil {
		return m.Config
	}
	return nil
}

func (m *Node) GetLogOffset() int64 {
	if m != nil {
		return m.LogOffset
	}
	return 0
}

func (m *Node) GetLogs() []*LogRecord {
	if m != nil {
		return m.Logs
	}
	return nil
}

func (m *Node) GetStatus() map[int64]*ReplicaStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type LogStatus struct {
	Committer *LeaderId   `protobuf:"bytes,4,opt,name=Committer,proto3" json:"Committer,omitempty"`
	Accepted  *TailBitmap `protobuf:"bytes,1,opt,name=Accepted,proto3" json:"Accepted,omitempty"`
}

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

var xxx_messageInfo_LogStatus proto.InternalMessageInfo

func (m *LogStatus) GetCommitter() *LeaderId {
	if m != nil {
		return m.Committer
	}
	return nil
}

func (m *LogStatus) GetAccepted() *TailBitmap {
	if m != nil {
		return m.Accepted
	}
	return nil
}

type ReplicaStatus struct {
	// last seen term+id
	// int64 Term = 3;
	// int64 Id = 10;
	// the last leader it voted for. or it is local term + local id.
	// E.g., voted for itself.
	//
	// TODO cleanup comment:
	// which replica it has voted for as a leader.
	//
	// Accepted is the same as VotedFor after receiving one log-replication
	// message from the leader.
	//
	// Before receiving a message, VotedFor is the leader this replica knows of,
	// Accepted is nil.
	VotedFor *LeaderId `protobuf:"bytes,10,opt,name=VotedFor,proto3" json:"VotedFor,omitempty"`
	// at what time the voted value expires,
	// in unix time in nanosecond: 10^-9 second
	VoteExpireAt int64 `protobuf:"varint,11,opt,name=VoteExpireAt,proto3" json:"VoteExpireAt,omitempty"`
	// The Leader tried to commit all of the local logs.
	// The Committer is the same as Author if a log entry is committed by its
	// Author.
	//
	// If an Author fails and the log is finally committed by some other leader,
	// Committer is a higher value than Author.
	//
	// It is similar to the vrnd/vballot concept in paxos.
	// the Ballot number a value is accepted at.
	Committer *LeaderId `protobuf:"bytes,4,opt,name=Committer,proto3" json:"Committer,omitempty"`
	// What logs has been accepted by this replica.
	Accepted  *TailBitmap `protobuf:"bytes,1,opt,name=Accepted,proto3" json:"Accepted,omitempty"`
	Committed *TailBitmap `protobuf:"bytes,2,opt,name=Committed,proto3" json:"Committed,omitempty"`
	Applied   *TailBitmap `protobuf:"bytes,3,opt,name=Applied,proto3" json:"Applied,omitempty"`
}

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

var xxx_messageInfo_ReplicaStatus proto.InternalMessageInfo

func (m *ReplicaStatus) GetVotedFor() *LeaderId {
	if m != nil {
		return m.VotedFor
	}
	return nil
}

func (m *ReplicaStatus) GetVoteExpireAt() int64 {
	if m != nil {
		return m.VoteExpireAt
	}
	return 0
}

func (m *ReplicaStatus) GetCommitter() *LeaderId {
	if m != nil {
		return m.Committer
	}
	return nil
}

func (m *ReplicaStatus) GetAccepted() *TailBitmap {
	if m != nil {
		return m.Accepted
	}
	return nil
}

func (m *ReplicaStatus) GetCommitted() *TailBitmap {
	if m != nil {
		return m.Committed
	}
	return nil
}

func (m *ReplicaStatus) GetApplied() *TailBitmap {
	if m != nil {
		return m.Applied
	}
	return nil
}

type ReplicaInfo struct {
	Id   int64  `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"`
	Addr string `protobuf:"bytes,2,opt,name=Addr,proto3" json:"Addr,omitempty"`
	// Position indicates the index of this member in its cluster.
	Position int64 `protobuf:"varint,3,opt,name=Position,proto3" json:"Position,omitempty"`
}

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

var xxx_messageInfo_ReplicaInfo proto.InternalMessageInfo

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

func (m *ReplicaInfo) GetAddr() string {
	if m != nil {
		return m.Addr
	}
	return ""
}

func (m *ReplicaInfo) GetPosition() int64 {
	if m != nil {
		return m.Position
	}
	return 0
}

type Cluster struct {
	Members map[int64]*ReplicaInfo `protobuf:"bytes,11,rep,name=Members,proto3" json:"Members,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Quorums []uint64               `protobuf:"varint,21,rep,packed,name=Quorums,proto3" json:"Quorums,omitempty"`
}

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

var xxx_messageInfo_Cluster proto.InternalMessageInfo

func (m *Cluster) GetMembers() map[int64]*ReplicaInfo {
	if m != nil {
		return m.Members
	}
	return nil
}

func (m *Cluster) GetQuorums() []uint64 {
	if m != nil {
		return m.Quorums
	}
	return nil
}

type ElectReq struct {
	// who initiates the election
	Candidate *LeaderId `protobuf:"bytes,1,opt,name=Candidate,proto3" json:"Candidate,omitempty"`
	// Latest leader that forwarded log to the candidate
	Committer *LeaderId `protobuf:"bytes,2,opt,name=Committer,proto3" json:"Committer,omitempty"`
	// what logs the candidate has.
	Accepted *TailBitmap `protobuf:"bytes,3,opt,name=Accepted,proto3" json:"Accepted,omitempty"`
}

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

var xxx_messageInfo_ElectReq proto.InternalMessageInfo

func (m *ElectReq) GetCandidate() *LeaderId {
	if m != nil {
		return m.Candidate
	}
	return nil
}

func (m *ElectReq) GetCommitter() *LeaderId {
	if m != nil {
		return m.Committer
	}
	return nil
}

func (m *ElectReq) GetAccepted() *TailBitmap {
	if m != nil {
		return m.Accepted
	}
	return nil
}

type ElectReply struct {
	OK bool `protobuf:"varint,10,opt,name=OK,proto3" json:"OK,omitempty"`
	// the replica id this reply comes from
	Id int64 `protobuf:"varint,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// voted for a candidate or the previous voted other leader.
	VotedFor *LeaderId `protobuf:"bytes,2,opt,name=VotedFor,proto3" json:"VotedFor,omitempty"`
	// latest log committer.
	Committer *LeaderId `protobuf:"bytes,4,opt,name=Committer,proto3" json:"Committer,omitempty"`
	// what logs I have.
	Accepted  *TailBitmap `protobuf:"bytes,21,opt,name=Accepted,proto3" json:"Accepted,omitempty"`
	Committed *TailBitmap `protobuf:"bytes,22,opt,name=Committed,proto3" json:"Committed,omitempty"`
	// The logs that voter has but leader candidate does not have.
	// For the leader to rebuild all possibly committed logs from a quorum.
	Logs []*LogRecord `protobuf:"bytes,30,rep,name=Logs,proto3" json:"Logs,omitempty"`
}

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

var xxx_messageInfo_ElectReply proto.InternalMessageInfo

func (m *ElectReply) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

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

func (m *ElectReply) GetVotedFor() *LeaderId {
	if m != nil {
		return m.VotedFor
	}
	return nil
}

func (m *ElectReply) GetCommitter() *LeaderId {
	if m != nil {
		return m.Committer
	}
	return nil
}

func (m *ElectReply) GetAccepted() *TailBitmap {
	if m != nil {
		return m.Accepted
	}
	return nil
}

func (m *ElectReply) GetCommitted() *TailBitmap {
	if m != nil {
		return m.Committed
	}
	return nil
}

func (m *ElectReply) GetLogs() []*LogRecord {
	if m != nil {
		return m.Logs
	}
	return nil
}

type LogForwardReq struct {
	Committer *LeaderId    `protobuf:"bytes,1,opt,name=Committer,proto3" json:"Committer,omitempty"`
	Logs      []*LogRecord `protobuf:"bytes,2,rep,name=Logs,proto3" json:"Logs,omitempty"`
	// Committed indicates logs committed by leader.
	// A follower should commit every log it has that is in Committed directly.
	Committed *TailBitmap `protobuf:"bytes,3,opt,name=Committed,proto3" json:"Committed,omitempty"`
}

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

var xxx_messageInfo_LogForwardReq proto.InternalMessageInfo

func (m *LogForwardReq) GetCommitter() *LeaderId {
	if m != nil {
		return m.Committer
	}
	return nil
}

func (m *LogForwardReq) GetLogs() []*LogRecord {
	if m != nil {
		return m.Logs
	}
	return nil
}

func (m *LogForwardReq) GetCommitted() *TailBitmap {
	if m != nil {
		return m.Committed
	}
	return nil
}

type LogForwardReply struct {
	OK bool `protobuf:"varint,10,opt,name=OK,proto3" json:"OK,omitempty"`
	// A replica responding a VotedFor with the same value with
	// ReplciateReq.Committer indicates the logs are accepted.
	// Otherwise declined.
	VotedFor  *LeaderId   `protobuf:"bytes,1,opt,name=VotedFor,proto3" json:"VotedFor,omitempty"`
	Accepted  *TailBitmap `protobuf:"bytes,2,opt,name=Accepted,proto3" json:"Accepted,omitempty"`
	Committed *TailBitmap `protobuf:"bytes,3,opt,name=Committed,proto3" json:"Committed,omitempty"`
}

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

var xxx_messageInfo_LogForwardReply proto.InternalMessageInfo

func (m *LogForwardReply) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

func (m *LogForwardReply) GetVotedFor() *LeaderId {
	if m != nil {
		return m.VotedFor
	}
	return nil
}

func (m *LogForwardReply) GetAccepted() *TailBitmap {
	if m != nil {
		return m.Accepted
	}
	return nil
}

func (m *LogForwardReply) GetCommitted() *TailBitmap {
	if m != nil {
		return m.Committed
	}
	return nil
}

type ProposeReply struct {
	OK  bool   `protobuf:"varint,2,opt,name=OK,proto3" json:"OK,omitempty"`
	Err string `protobuf:"bytes,3,opt,name=Err,proto3" json:"Err,omitempty"`
	// I am not leader, please redirect to `OtherLeader` to write to TRaft.
	OtherLeader *LeaderId `protobuf:"bytes,1,opt,name=OtherLeader,proto3" json:"OtherLeader,omitempty"`
}

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

var xxx_messageInfo_ProposeReply proto.InternalMessageInfo

func (m *ProposeReply) GetOK() bool {
	if m != nil {
		return m.OK
	}
	return false
}

func (m *ProposeReply) GetErr() string {
	if m != nil {
		return m.Err
	}
	return ""
}

func (m *ProposeReply) GetOtherLeader() *LeaderId {
	if m != nil {
		return m.OtherLeader
	}
	return nil
}

func init() {
	proto.RegisterType((*Cmd)(nil), "Cmd")
	proto.RegisterType((*TailBitmap)(nil), "TailBitmap")
	proto.RegisterType((*LogRecord)(nil), "LogRecord")
	proto.RegisterType((*LeaderId)(nil), "LeaderId")
	proto.RegisterType((*Node)(nil), "Node")
	proto.RegisterMapType((map[int64]*ReplicaStatus)(nil), "Node.StatusEntry")
	proto.RegisterType((*LogStatus)(nil), "LogStatus")
	proto.RegisterType((*ReplicaStatus)(nil), "ReplicaStatus")
	proto.RegisterType((*ReplicaInfo)(nil), "ReplicaInfo")
	proto.RegisterType((*Cluster)(nil), "Cluster")
	proto.RegisterMapType((map[int64]*ReplicaInfo)(nil), "Cluster.MembersEntry")
	proto.RegisterType((*ElectReq)(nil), "ElectReq")
	proto.RegisterType((*ElectReply)(nil), "ElectReply")
	proto.RegisterType((*LogForwardReq)(nil), "LogForwardReq")
	proto.RegisterType((*LogForwardReply)(nil), "LogForwardReply")
	proto.RegisterType((*ProposeReply)(nil), "ProposeReply")
}

func init() { proto.RegisterFile("traft.proto", fileDescriptor_39aa4f94ef5dbc0b) }

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

func (this *Cmd) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Cmd)
	if !ok {
		that2, ok := that.(Cmd)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Op != that1.Op {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if that1.Value == nil {
		if this.Value != nil {
			return false
		}
	} else if this.Value == nil {
		return false
	} else if !this.Value.Equal(that1.Value) {
		return false
	}
	return true
}
func (this *Cmd_VStr) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Cmd_VStr)
	if !ok {
		that2, ok := that.(Cmd_VStr)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.VStr != that1.VStr {
		return false
	}
	return true
}
func (this *Cmd_VI64) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Cmd_VI64)
	if !ok {
		that2, ok := that.(Cmd_VI64)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.VI64 != that1.VI64 {
		return false
	}
	return true
}
func (this *Cmd_VClusterConfig) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Cmd_VClusterConfig)
	if !ok {
		that2, ok := that.(Cmd_VClusterConfig)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.VClusterConfig.Equal(that1.VClusterConfig) {
		return false
	}
	return true
}
func (this *TailBitmap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TailBitmap)
	if !ok {
		that2, ok := that.(TailBitmap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	if len(this.Words) != len(that1.Words) {
		return false
	}
	for i := range this.Words {
		if this.Words[i] != that1.Words[i] {
			return false
		}
	}
	if this.Reclamed != that1.Reclamed {
		return false
	}
	return true
}
func (this *LogRecord) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogRecord)
	if !ok {
		that2, ok := that.(LogRecord)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Author.Equal(that1.Author) {
		return false
	}
	if this.Seq != that1.Seq {
		return false
	}
	if !this.Cmd.Equal(that1.Cmd) {
		return false
	}
	if !this.Depends.Equal(that1.Depends) {
		return false
	}
	if !this.Overrides.Equal(that1.Overrides) {
		return false
	}
	return true
}
func (this *LeaderId) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LeaderId)
	if !ok {
		that2, ok := that.(LeaderId)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Term != that1.Term {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	return true
}
func (this *Node) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Node)
	if !ok {
		that2, ok := that.(Node)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if !this.Config.Equal(that1.Config) {
		return false
	}
	if this.LogOffset != that1.LogOffset {
		return false
	}
	if len(this.Logs) != len(that1.Logs) {
		return false
	}
	for i := range this.Logs {
		if !this.Logs[i].Equal(that1.Logs[i]) {
			return false
		}
	}
	if len(this.Status) != len(that1.Status) {
		return false
	}
	for i := range this.Status {
		if !this.Status[i].Equal(that1.Status[i]) {
			return false
		}
	}
	return true
}
func (this *LogStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogStatus)
	if !ok {
		that2, ok := that.(LogStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Committer.Equal(that1.Committer) {
		return false
	}
	if !this.Accepted.Equal(that1.Accepted) {
		return false
	}
	return true
}
func (this *ReplicaStatus) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaStatus)
	if !ok {
		that2, ok := that.(ReplicaStatus)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.VotedFor.Equal(that1.VotedFor) {
		return false
	}
	if this.VoteExpireAt != that1.VoteExpireAt {
		return false
	}
	if !this.Committer.Equal(that1.Committer) {
		return false
	}
	if !this.Accepted.Equal(that1.Accepted) {
		return false
	}
	if !this.Committed.Equal(that1.Committed) {
		return false
	}
	if !this.Applied.Equal(that1.Applied) {
		return false
	}
	return true
}
func (this *ReplicaInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicaInfo)
	if !ok {
		that2, ok := that.(ReplicaInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if this.Addr != that1.Addr {
		return false
	}
	if this.Position != that1.Position {
		return false
	}
	return true
}
func (this *Cluster) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Cluster)
	if !ok {
		that2, ok := that.(Cluster)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Members) != len(that1.Members) {
		return false
	}
	for i := range this.Members {
		if !this.Members[i].Equal(that1.Members[i]) {
			return false
		}
	}
	if len(this.Quorums) != len(that1.Quorums) {
		return false
	}
	for i := range this.Quorums {
		if this.Quorums[i] != that1.Quorums[i] {
			return false
		}
	}
	return true
}
func (this *ElectReq) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ElectReq)
	if !ok {
		that2, ok := that.(ElectReq)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Candidate.Equal(that1.Candidate) {
		return false
	}
	if !this.Committer.Equal(that1.Committer) {
		return false
	}
	if !this.Accepted.Equal(that1.Accepted) {
		return false
	}
	return true
}
func (this *ElectReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ElectReply)
	if !ok {
		that2, ok := that.(ElectReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.OK != that1.OK {
		return false
	}
	if this.Id != that1.Id {
		return false
	}
	if !this.VotedFor.Equal(that1.VotedFor) {
		return false
	}
	if !this.Committer.Equal(that1.Committer) {
		return false
	}
	if !this.Accepted.Equal(that1.Accepted) {
		return false
	}
	if !this.Committed.Equal(that1.Committed) {
		return false
	}
	if len(this.Logs) != len(that1.Logs) {
		return false
	}
	for i := range this.Logs {
		if !this.Logs[i].Equal(that1.Logs[i]) {
			return false
		}
	}
	return true
}
func (this *LogForwardReq) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogForwardReq)
	if !ok {
		that2, ok := that.(LogForwardReq)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Committer.Equal(that1.Committer) {
		return false
	}
	if len(this.Logs) != len(that1.Logs) {
		return false
	}
	for i := range this.Logs {
		if !this.Logs[i].Equal(that1.Logs[i]) {
			return false
		}
	}
	if !this.Committed.Equal(that1.Committed) {
		return false
	}
	return true
}
func (this *LogForwardReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LogForwardReply)
	if !ok {
		that2, ok := that.(LogForwardReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.OK != that1.OK {
		return false
	}
	if !this.VotedFor.Equal(that1.VotedFor) {
		return false
	}
	if !this.Accepted.Equal(that1.Accepted) {
		return false
	}
	if !this.Committed.Equal(that1.Committed) {
		return false
	}
	return true
}
func (this *ProposeReply) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ProposeReply)
	if !ok {
		that2, ok := that.(ProposeReply)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.OK != that1.OK {
		return false
	}
	if this.Err != that1.Err {
		return false
	}
	if !this.OtherLeader.Equal(that1.OtherLeader) {
		return false
	}
	return true
}

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

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

// TRaftClient is the client API for TRaft service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type TRaftClient interface {
	Elect(ctx context.Context, in *ElectReq, opts ...grpc.CallOption) (*ElectReply, error)
	LogForward(ctx context.Context, in *LogForwardReq, opts ...grpc.CallOption) (*LogForwardReply, error)
	Propose(ctx context.Context, in *Cmd, opts ...grpc.CallOption) (*ProposeReply, error)
}

type tRaftClient struct {
	cc *grpc.ClientConn
}

func NewTRaftClient(cc *grpc.ClientConn) TRaftClient {
	return &tRaftClient{cc}
}

func (c *tRaftClient) Elect(ctx context.Context, in *ElectReq, opts ...grpc.CallOption) (*ElectReply, error) {
	out := new(ElectReply)
	err := c.cc.Invoke(ctx, "/TRaft/Elect", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tRaftClient) LogForward(ctx context.Context, in *LogForwardReq, opts ...grpc.CallOption) (*LogForwardReply, error) {
	out := new(LogForwardReply)
	err := c.cc.Invoke(ctx, "/TRaft/LogForward", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *tRaftClient) Propose(ctx context.Context, in *Cmd, opts ...grpc.CallOption) (*ProposeReply, error) {
	out := new(ProposeReply)
	err := c.cc.Invoke(ctx, "/TRaft/Propose", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TRaftServer is the server API for TRaft service.
type TRaftServer interface {
	Elect(context.Context, *ElectReq) (*ElectReply, error)
	LogForward(context.Context, *LogForwardReq) (*LogForwardReply, error)
	Propose(context.Context, *Cmd) (*ProposeReply, error)
}

// UnimplementedTRaftServer can be embedded to have forward compatible implementations.
type UnimplementedTRaftServer struct {
}

func (*UnimplementedTRaftServer) Elect(ctx context.Context, req *ElectReq) (*ElectReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Elect not implemented")
}
func (*UnimplementedTRaftServer) LogForward(ctx context.Context, req *LogForwardReq) (*LogForwardReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LogForward not implemented")
}
func (*UnimplementedTRaftServer) Propose(ctx context.Context, req *Cmd) (*ProposeReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Propose not implemented")
}

func RegisterTRaftServer(s *grpc.Server, srv TRaftServer) {
	s.RegisterService(&_TRaft_serviceDesc, srv)
}

func _TRaft_Elect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ElectReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TRaftServer).Elect(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/TRaft/Elect",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TRaftServer).Elect(ctx, req.(*ElectReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _TRaft_LogForward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LogForwardReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TRaftServer).LogForward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/TRaft/LogForward",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TRaftServer).LogForward(ctx, req.(*LogForwardReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _TRaft_Propose_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Cmd)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TRaftServer).Propose(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/TRaft/Propose",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TRaftServer).Propose(ctx, req.(*Cmd))
	}
	return interceptor(ctx, in, info, handler)
}

var _TRaft_serviceDesc = grpc.ServiceDesc{
	ServiceName: "TRaft",
	HandlerType: (*TRaftServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Elect",
			Handler:    _TRaft_Elect_Handler,
		},
		{
			MethodName: "LogForward",
			Handler:    _TRaft_LogForward_Handler,
		},
		{
			MethodName: "Propose",
			Handler:    _TRaft_Propose_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "traft.proto",
}

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

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

func (m *Cmd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Value != nil {
		{
			size := m.Value.Size()
			i -= size
			if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintTraft(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if len(m.Op) > 0 {
		i -= len(m.Op)
		copy(dAtA[i:], m.Op)
		i = encodeVarintTraft(dAtA, i, uint64(len(m.Op)))
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}

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

func (m *Cmd_VStr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i -= len(m.VStr)
	copy(dAtA[i:], m.VStr)
	i = encodeVarintTraft(dAtA, i, uint64(len(m.VStr)))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xfa
	return len(dAtA) - i, nil
}
func (m *Cmd_VI64) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Cmd_VI64) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	i = encodeVarintTraft(dAtA, i, uint64(m.VI64))
	i--
	dAtA[i] = 0x2
	i--
	dAtA[i] = 0x80
	return len(dAtA) - i, nil
}
func (m *Cmd_VClusterConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Cmd_VClusterConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.VClusterConfig != nil {
		{
			size, err := m.VClusterConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x8a
	}
	return len(dAtA) - i, nil
}
func (m *TailBitmap) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

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

func (m *TailBitmap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Reclamed != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Reclamed))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Words) > 0 {
		dAtA3 := make([]byte, len(m.Words)*10)
		var j2 int
		for _, num := range m.Words {
			for num >= 1<<7 {
				dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j2++
			}
			dAtA3[j2] = uint8(num)
			j2++
		}
		i -= j2
		copy(dAtA[i:], dAtA3[:j2])
		i = encodeVarintTraft(dAtA, i, uint64(j2))
		i--
		dAtA[i] = 0x12
	}
	if m.Offset != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Overrides != nil {
		{
			size, err := m.Overrides.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc2
	}
	if m.Depends != nil {
		{
			size, err := m.Depends.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0x82
	}
	if m.Cmd != nil {
		{
			size, err := m.Cmd.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xf2
	}
	if m.Seq != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Seq))
		i--
		dAtA[i] = 0x50
	}
	if m.Author != nil {
		{
			size, err := m.Author.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LeaderId) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Id != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x10
	}
	if m.Term != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Term))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Node) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Status) > 0 {
		for k := range m.Status {
			v := m.Status[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTraft(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTraft(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTraft(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if m.LogOffset != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.LogOffset))
		i--
		dAtA[i] = 0x20
	}
	if m.Id != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTraft(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Committer != nil {
		{
			size, err := m.Committer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Accepted != nil {
		{
			size, err := m.Accepted.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ReplicaStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.VoteExpireAt != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.VoteExpireAt))
		i--
		dAtA[i] = 0x58
	}
	if m.VotedFor != nil {
		{
			size, err := m.VotedFor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.Committer != nil {
		{
			size, err := m.Committer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Applied != nil {
		{
			size, err := m.Applied.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Committed != nil {
		{
			size, err := m.Committed.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Accepted != nil {
		{
			size, err := m.Accepted.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ReplicaInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Position != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Position))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Addr) > 0 {
		i -= len(m.Addr)
		copy(dAtA[i:], m.Addr)
		i = encodeVarintTraft(dAtA, i, uint64(len(m.Addr)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *Cluster) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Quorums) > 0 {
		dAtA18 := make([]byte, len(m.Quorums)*10)
		var j17 int
		for _, num := range m.Quorums {
			for num >= 1<<7 {
				dAtA18[j17] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j17++
			}
			dAtA18[j17] = uint8(num)
			j17++
		}
		i -= j17
		copy(dAtA[i:], dAtA18[:j17])
		i = encodeVarintTraft(dAtA, i, uint64(j17))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if len(m.Members) > 0 {
		for k := range m.Members {
			v := m.Members[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTraft(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i = encodeVarintTraft(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintTraft(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x5a
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ElectReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Accepted != nil {
		{
			size, err := m.Accepted.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Committer != nil {
		{
			size, err := m.Committer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Candidate != nil {
		{
			size, err := m.Candidate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ElectReply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTraft(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xf2
		}
	}
	if m.Committed != nil {
		{
			size, err := m.Committed.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb2
	}
	if m.Accepted != nil {
		{
			size, err := m.Accepted.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xaa
	}
	if m.OK {
		i--
		if m.OK {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.Committer != nil {
		{
			size, err := m.Committer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.VotedFor != nil {
		{
			size, err := m.VotedFor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = encodeVarintTraft(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogForwardReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Committed != nil {
		{
			size, err := m.Committed.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Logs) > 0 {
		for iNdEx := len(m.Logs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Logs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTraft(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.Committer != nil {
		{
			size, err := m.Committer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *LogForwardReply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OK {
		i--
		if m.OK {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if m.Committed != nil {
		{
			size, err := m.Committed.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Accepted != nil {
		{
			size, err := m.Accepted.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.VotedFor != nil {
		{
			size, err := m.VotedFor.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *ProposeReply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Err) > 0 {
		i -= len(m.Err)
		copy(dAtA[i:], m.Err)
		i = encodeVarintTraft(dAtA, i, uint64(len(m.Err)))
		i--
		dAtA[i] = 0x1a
	}
	if m.OK {
		i--
		if m.OK {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.OtherLeader != nil {
		{
			size, err := m.OtherLeader.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTraft(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintTraft(dAtA []byte, offset int, v uint64) int {
	offset -= sovTraft(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Cmd) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Op)
	if l > 0 {
		n += 1 + l + sovTraft(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 2 + l + sovTraft(uint64(l))
	}
	if m.Value != nil {
		n += m.Value.Size()
	}
	return n
}

func (m *Cmd_VStr) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.VStr)
	n += 2 + l + sovTraft(uint64(l))
	return n
}
func (m *Cmd_VI64) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2 + sovTraft(uint64(m.VI64))
	return n
}
func (m *Cmd_VClusterConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VClusterConfig != nil {
		l = m.VClusterConfig.Size()
		n += 2 + l + sovTraft(uint64(l))
	}
	return n
}
func (m *TailBitmap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Offset != 0 {
		n += 1 + sovTraft(uint64(m.Offset))
	}
	if len(m.Words) > 0 {
		l = 0
		for _, e := range m.Words {
			l += sovTraft(uint64(e))
		}
		n += 1 + sovTraft(uint64(l)) + l
	}
	if m.Reclamed != 0 {
		n += 1 + sovTraft(uint64(m.Reclamed))
	}
	return n
}

func (m *LogRecord) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Author != nil {
		l = m.Author.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Seq != 0 {
		n += 1 + sovTraft(uint64(m.Seq))
	}
	if m.Cmd != nil {
		l = m.Cmd.Size()
		n += 2 + l + sovTraft(uint64(l))
	}
	if m.Depends != nil {
		l = m.Depends.Size()
		n += 2 + l + sovTraft(uint64(l))
	}
	if m.Overrides != nil {
		l = m.Overrides.Size()
		n += 2 + l + sovTraft(uint64(l))
	}
	return n
}

func (m *LeaderId) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Term != 0 {
		n += 1 + sovTraft(uint64(m.Term))
	}
	if m.Id != 0 {
		n += 1 + sovTraft(uint64(m.Id))
	}
	return n
}

func (m *Node) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Config != nil {
		l = m.Config.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 1 + l + sovTraft(uint64(l))
		}
	}
	if m.Id != 0 {
		n += 1 + sovTraft(uint64(m.Id))
	}
	if m.LogOffset != 0 {
		n += 1 + sovTraft(uint64(m.LogOffset))
	}
	if len(m.Status) > 0 {
		for k, v := range m.Status {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTraft(uint64(l))
			}
			mapEntrySize := 1 + sovTraft(uint64(k)) + l
			n += mapEntrySize + 1 + sovTraft(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *LogStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Accepted != nil {
		l = m.Accepted.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Committer != nil {
		l = m.Committer.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	return n
}

func (m *ReplicaStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Accepted != nil {
		l = m.Accepted.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Committed != nil {
		l = m.Committed.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Applied != nil {
		l = m.Applied.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Committer != nil {
		l = m.Committer.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.VotedFor != nil {
		l = m.VotedFor.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.VoteExpireAt != 0 {
		n += 1 + sovTraft(uint64(m.VoteExpireAt))
	}
	return n
}

func (m *ReplicaInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovTraft(uint64(m.Id))
	}
	l = len(m.Addr)
	if l > 0 {
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Position != 0 {
		n += 1 + sovTraft(uint64(m.Position))
	}
	return n
}

func (m *Cluster) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Members) > 0 {
		for k, v := range m.Members {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTraft(uint64(l))
			}
			mapEntrySize := 1 + sovTraft(uint64(k)) + l
			n += mapEntrySize + 1 + sovTraft(uint64(mapEntrySize))
		}
	}
	if len(m.Quorums) > 0 {
		l = 0
		for _, e := range m.Quorums {
			l += sovTraft(uint64(e))
		}
		n += 2 + sovTraft(uint64(l)) + l
	}
	return n
}

func (m *ElectReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Candidate != nil {
		l = m.Candidate.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Committer != nil {
		l = m.Committer.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Accepted != nil {
		l = m.Accepted.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	return n
}

func (m *ElectReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovTraft(uint64(m.Id))
	}
	if m.VotedFor != nil {
		l = m.VotedFor.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Committer != nil {
		l = m.Committer.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.OK {
		n += 2
	}
	if m.Accepted != nil {
		l = m.Accepted.Size()
		n += 2 + l + sovTraft(uint64(l))
	}
	if m.Committed != nil {
		l = m.Committed.Size()
		n += 2 + l + sovTraft(uint64(l))
	}
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 2 + l + sovTraft(uint64(l))
		}
	}
	return n
}

func (m *LogForwardReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Committer != nil {
		l = m.Committer.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if len(m.Logs) > 0 {
		for _, e := range m.Logs {
			l = e.Size()
			n += 1 + l + sovTraft(uint64(l))
		}
	}
	if m.Committed != nil {
		l = m.Committed.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	return n
}

func (m *LogForwardReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VotedFor != nil {
		l = m.VotedFor.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Accepted != nil {
		l = m.Accepted.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.Committed != nil {
		l = m.Committed.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.OK {
		n += 2
	}
	return n
}

func (m *ProposeReply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OtherLeader != nil {
		l = m.OtherLeader.Size()
		n += 1 + l + sovTraft(uint64(l))
	}
	if m.OK {
		n += 2
	}
	l = len(m.Err)
	if l > 0 {
		n += 1 + l + sovTraft(uint64(l))
	}
	return n
}

func sovTraft(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTraft(x uint64) (n int) {
	return sovTraft(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Cmd) 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 ErrIntOverflowTraft
			}
			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: Cmd: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Cmd: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Op = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 31:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VStr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = &Cmd_VStr{string(dAtA[iNdEx:postIndex])}
			iNdEx = postIndex
		case 32:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VI64", wireType)
			}
			var v int64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Value = &Cmd_VI64{v}
		case 33:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VClusterConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &Cluster{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Value = &Cmd_VClusterConfig{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TailBitmap) 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 ErrIntOverflowTraft
			}
			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: TailBitmap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TailBitmap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= int64(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 ErrIntOverflowTraft
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Words = append(m.Words, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTraft
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTraft
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTraft
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Words) == 0 {
					m.Words = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTraft
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Words = append(m.Words, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Words", wireType)
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reclamed", wireType)
			}
			m.Reclamed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Reclamed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogRecord) 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 ErrIntOverflowTraft
			}
			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: LogRecord: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogRecord: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Author", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Author == nil {
				m.Author = &LeaderId{}
			}
			if err := m.Author.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			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 ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Seq |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cmd", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cmd == nil {
				m.Cmd = &Cmd{}
			}
			if err := m.Cmd.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 32:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Depends", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Depends == nil {
				m.Depends = &TailBitmap{}
			}
			if err := m.Depends.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 40:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Overrides", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Overrides == nil {
				m.Overrides = &TailBitmap{}
			}
			if err := m.Overrides.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LeaderId) 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 ErrIntOverflowTraft
			}
			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: LeaderId: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LeaderId: 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 ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Term |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			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 ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Node) 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 ErrIntOverflowTraft
			}
			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: Node: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Node: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &Cluster{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logs = append(m.Logs, &LogRecord{})
			if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogOffset", wireType)
			}
			m.LogOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogOffset |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = make(map[int64]*ReplicaStatus)
			}
			var mapkey int64
			var mapvalue *ReplicaStatus
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTraft
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTraft
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTraft
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTraft
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTraft
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ReplicaStatus{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTraft(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTraft
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Status[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogStatus) 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 ErrIntOverflowTraft
			}
			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: LogStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accepted", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Accepted == nil {
				m.Accepted = &TailBitmap{}
			}
			if err := m.Accepted.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Committer == nil {
				m.Committer = &LeaderId{}
			}
			if err := m.Committer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaStatus) 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 ErrIntOverflowTraft
			}
			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: ReplicaStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accepted", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Accepted == nil {
				m.Accepted = &TailBitmap{}
			}
			if err := m.Accepted.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Committed == nil {
				m.Committed = &TailBitmap{}
			}
			if err := m.Committed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Applied", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Applied == nil {
				m.Applied = &TailBitmap{}
			}
			if err := m.Applied.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Committer == nil {
				m.Committer = &LeaderId{}
			}
			if err := m.Committer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotedFor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VotedFor == nil {
				m.VotedFor = &LeaderId{}
			}
			if err := m.VotedFor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VoteExpireAt", wireType)
			}
			m.VoteExpireAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VoteExpireAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicaInfo) 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 ErrIntOverflowTraft
			}
			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: ReplicaInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicaInfo: 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 ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Addr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Position", wireType)
			}
			m.Position = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Position |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Cluster) 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 ErrIntOverflowTraft
			}
			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: Cluster: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Cluster: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Members == nil {
				m.Members = make(map[int64]*ReplicaInfo)
			}
			var mapkey int64
			var mapvalue *ReplicaInfo
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTraft
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTraft
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTraft
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTraft
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTraft
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ReplicaInfo{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTraft(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTraft
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Members[mapkey] = mapvalue
			iNdEx = postIndex
		case 21:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTraft
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Quorums = append(m.Quorums, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTraft
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthTraft
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthTraft
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Quorums) == 0 {
					m.Quorums = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTraft
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Quorums = append(m.Quorums, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Quorums", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ElectReply) 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 ErrIntOverflowTraft
			}
			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: ElectReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ElectReply: 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 ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotedFor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VotedFor == nil {
				m.VotedFor = &LeaderId{}
			}
			if err := m.VotedFor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Committer == nil {
				m.Committer = &LeaderId{}
			}
			if err := m.Committer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OK", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OK = bool(v != 0)
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accepted", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Accepted == nil {
				m.Accepted = &TailBitmap{}
			}
			if err := m.Accepted.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Committed == nil {
				m.Committed = &TailBitmap{}
			}
			if err := m.Committed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 30:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Logs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Logs = append(m.Logs, &LogRecord{})
			if err := m.Logs[len(m.Logs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogForwardReply) 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 ErrIntOverflowTraft
			}
			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: LogForwardReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogForwardReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VotedFor", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VotedFor == nil {
				m.VotedFor = &LeaderId{}
			}
			if err := m.VotedFor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Accepted", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Accepted == nil {
				m.Accepted = &TailBitmap{}
			}
			if err := m.Accepted.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Committed == nil {
				m.Committed = &TailBitmap{}
			}
			if err := m.Committed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OK", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OK = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProposeReply) 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 ErrIntOverflowTraft
			}
			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: ProposeReply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProposeReply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OtherLeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OtherLeader == nil {
				m.OtherLeader = &LeaderId{}
			}
			if err := m.OtherLeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OK", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.OK = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Err", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTraft
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTraft
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Err = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTraft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTraft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTraft(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTraft
			}
			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, ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTraft
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTraft
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTraft
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTraft
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTraft        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTraft          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTraft = fmt.Errorf("proto: unexpected end of group")
)