paxos.pb.go

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

package paxospb

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type MessageType int32

const (
	LocalTick                       MessageType = 0
	PaxosPrepare                    MessageType = 1
	PaxosPrepareReply               MessageType = 2
	PaxosAccept                     MessageType = 3
	PaxosAcceptReply                MessageType = 4
	PaxosLearnerAskForLearn         MessageType = 5
	PaxosLearnerSendNowInstanceID   MessageType = 6
	PaxosLearnerConfirmAskForLearn  MessageType = 7
	PaxosLearnerSendLearnValue      MessageType = 8
	PaxosLearnerProposerSendSuccess MessageType = 9
	Propose                         MessageType = 10
	NoOP                            MessageType = 11
	PaxosProposalSendNewValue       MessageType = 12
)

var MessageType_name = map[int32]string{
	0:  "LocalTick",
	1:  "PaxosPrepare",
	2:  "PaxosPrepareReply",
	3:  "PaxosAccept",
	4:  "PaxosAcceptReply",
	5:  "PaxosLearnerAskForLearn",
	6:  "PaxosLearnerSendNowInstanceID",
	7:  "PaxosLearnerConfirmAskForLearn",
	8:  "PaxosLearnerSendLearnValue",
	9:  "PaxosLearnerProposerSendSuccess",
	10: "Propose",
	11: "NoOP",
	12: "PaxosProposalSendNewValue",
}

var MessageType_value = map[string]int32{
	"LocalTick":                       0,
	"PaxosPrepare":                    1,
	"PaxosPrepareReply":               2,
	"PaxosAccept":                     3,
	"PaxosAcceptReply":                4,
	"PaxosLearnerAskForLearn":         5,
	"PaxosLearnerSendNowInstanceID":   6,
	"PaxosLearnerConfirmAskForLearn":  7,
	"PaxosLearnerSendLearnValue":      8,
	"PaxosLearnerProposerSendSuccess": 9,
	"Propose":                         10,
	"NoOP":                            11,
	"PaxosProposalSendNewValue":       12,
}

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

func (x MessageType) String() string {
	return proto.EnumName(MessageType_name, int32(x))
}

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

func (MessageType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_fec356ed5fe8331d, []int{0}
}

type EntryType int32

const (
	ApplicationEntry  EntryType = 0
	ConfigChangeEntry EntryType = 1
)

var EntryType_name = map[int32]string{
	0: "ApplicationEntry",
	1: "ConfigChangeEntry",
}

var EntryType_value = map[string]int32{
	"ApplicationEntry":  0,
	"ConfigChangeEntry": 1,
}

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

func (x EntryType) String() string {
	return proto.EnumName(EntryType_name, int32(x))
}

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

func (EntryType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_fec356ed5fe8331d, []int{1}
}

type ChecksumType int32

const (
	CRC32IEEE ChecksumType = 0
	HIGHWAY   ChecksumType = 1
)

var ChecksumType_name = map[int32]string{
	0: "CRC32IEEE",
	1: "HIGHWAY",
}

var ChecksumType_value = map[string]int32{
	"CRC32IEEE": 0,
	"HIGHWAY":   1,
}

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

func (x ChecksumType) String() string {
	return proto.EnumName(ChecksumType_name, int32(x))
}

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

func (ChecksumType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_fec356ed5fe8331d, []int{2}
}

type PaxosDataStatus struct {
	Address  string `protobuf:"bytes,1,opt,name=address" json:"address"`
	BinVer   uint32 `protobuf:"varint,2,opt,name=bin_ver,json=binVer" json:"bin_ver"`
	HardHash uint64 `protobuf:"varint,3,opt,name=hard_hash,json=hardHash" json:"hard_hash"`
}

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

var xxx_messageInfo_PaxosDataStatus proto.InternalMessageInfo

func (m *PaxosDataStatus) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *PaxosDataStatus) GetBinVer() uint32 {
	if m != nil {
		return m.BinVer
	}
	return 0
}

func (m *PaxosDataStatus) GetHardHash() uint64 {
	if m != nil {
		return m.HardHash
	}
	return 0
}

type PaxosMsg struct {
	MsgType             MessageType `protobuf:"varint,1,opt,name=MsgType,json=msgType,enum=paxospb.MessageType" json:"MsgType"`
	To                  uint64      `protobuf:"varint,2,opt,name=To,json=to" json:"To"`
	From                uint64      `protobuf:"varint,3,opt,name=From,json=from" json:"From"`
	GroupID             uint64      `protobuf:"varint,4,opt,name=GroupID,json=groupID" json:"GroupID"`
	InstanceID          uint64      `protobuf:"varint,5,opt,name=InstanceID,json=instanceID" json:"InstanceID"`
	ProposalID          uint64      `protobuf:"varint,6,opt,name=ProposalID,json=proposalID" json:"ProposalID"`
	ProposalNodeID      uint64      `protobuf:"varint,7,opt,name=ProposalNodeID,json=proposalNodeID" json:"ProposalNodeID"`
	Key                 uint64      `protobuf:"varint,15,opt,name=Key,json=key" json:"Key"`
	Value               []byte      `protobuf:"bytes,8,opt,name=Value,json=value" json:"Value"`
	PreAcceptID         uint64      `protobuf:"varint,9,opt,name=PreAcceptID,json=preAcceptID" json:"PreAcceptID"`
	PreAcceptNodeID     uint64      `protobuf:"varint,10,opt,name=PreAcceptNodeID,json=preAcceptNodeID" json:"PreAcceptNodeID"`
	RejectByPromiseID   uint64      `protobuf:"varint,11,opt,name=RejectByPromiseID,json=rejectByPromiseID" json:"RejectByPromiseID"`
	NowInstanceID       uint64      `protobuf:"varint,12,opt,name=NowInstanceID,json=nowInstanceID" json:"NowInstanceID"`
	MinChosenInstanceID uint64      `protobuf:"varint,13,opt,name=MinChosenInstanceID,json=minChosenInstanceID" json:"MinChosenInstanceID"`
	Flag                uint32      `protobuf:"varint,14,opt,name=Flag,json=flag" json:"Flag"`
}

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

var xxx_messageInfo_PaxosMsg proto.InternalMessageInfo

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

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

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

func (m *PaxosMsg) GetGroupID() uint64 {
	if m != nil {
		return m.GroupID
	}
	return 0
}

func (m *PaxosMsg) GetInstanceID() uint64 {
	if m != nil {
		return m.InstanceID
	}
	return 0
}

func (m *PaxosMsg) GetProposalID() uint64 {
	if m != nil {
		return m.ProposalID
	}
	return 0
}

func (m *PaxosMsg) GetProposalNodeID() uint64 {
	if m != nil {
		return m.ProposalNodeID
	}
	return 0
}

func (m *PaxosMsg) GetKey() uint64 {
	if m != nil {
		return m.Key
	}
	return 0
}

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

func (m *PaxosMsg) GetPreAcceptID() uint64 {
	if m != nil {
		return m.PreAcceptID
	}
	return 0
}

func (m *PaxosMsg) GetPreAcceptNodeID() uint64 {
	if m != nil {
		return m.PreAcceptNodeID
	}
	return 0
}

func (m *PaxosMsg) GetRejectByPromiseID() uint64 {
	if m != nil {
		return m.RejectByPromiseID
	}
	return 0
}

func (m *PaxosMsg) GetNowInstanceID() uint64 {
	if m != nil {
		return m.NowInstanceID
	}
	return 0
}

func (m *PaxosMsg) GetMinChosenInstanceID() uint64 {
	if m != nil {
		return m.MinChosenInstanceID
	}
	return 0
}

func (m *PaxosMsg) GetFlag() uint32 {
	if m != nil {
		return m.Flag
	}
	return 0
}

type MessageBatch struct {
	Requests      []PaxosMsg `protobuf:"bytes,1,rep,name=requests" json:"requests"`
	SourceAddress string     `protobuf:"bytes,2,opt,name=source_address,json=sourceAddress" json:"source_address"`
	BinVer        uint32     `protobuf:"varint,3,opt,name=bin_ver,json=binVer" json:"bin_ver"`
}

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

var xxx_messageInfo_MessageBatch proto.InternalMessageInfo

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

func (m *MessageBatch) GetSourceAddress() string {
	if m != nil {
		return m.SourceAddress
	}
	return ""
}

func (m *MessageBatch) GetBinVer() uint32 {
	if m != nil {
		return m.BinVer
	}
	return 0
}

type State struct {
	Commit        uint64        `protobuf:"varint,1,opt,name=commit" json:"commit"`
	AcceptorState AcceptorState `protobuf:"bytes,2,opt,name=AcceptorState,json=acceptorState" json:"AcceptorState"`
}

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

var xxx_messageInfo_State proto.InternalMessageInfo

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

func (m *State) GetAcceptorState() AcceptorState {
	if m != nil {
		return m.AcceptorState
	}
	return AcceptorState{}
}

type Entry struct {
	Type          EntryType     `protobuf:"varint,1,opt,name=Type,json=type,enum=paxospb.EntryType" json:"Type"`
	Key           uint64        `protobuf:"varint,2,opt,name=Key,json=key" json:"Key"`
	AcceptorState AcceptorState `protobuf:"bytes,3,opt,name=AcceptorState,json=acceptorState" json:"AcceptorState"`
}

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

var xxx_messageInfo_Entry proto.InternalMessageInfo

func (m *Entry) GetType() EntryType {
	if m != nil {
		return m.Type
	}
	return ApplicationEntry
}

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

func (m *Entry) GetAcceptorState() AcceptorState {
	if m != nil {
		return m.AcceptorState
	}
	return AcceptorState{}
}

type Membership struct {
	ConfigChangeId uint64            `protobuf:"varint,1,opt,name=config_change_id,json=configChangeId" json:"config_change_id"`
	Addresses      map[uint64]string `protobuf:"bytes,2,rep,name=addresses" json:"addresses,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	Removed        map[uint64]bool   `protobuf:"bytes,3,rep,name=removed" json:"removed,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
}

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

var xxx_messageInfo_Membership proto.InternalMessageInfo

func (m *Membership) GetConfigChangeId() uint64 {
	if m != nil {
		return m.ConfigChangeId
	}
	return 0
}

func (m *Membership) GetAddresses() map[uint64]string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *Membership) GetRemoved() map[uint64]bool {
	if m != nil {
		return m.Removed
	}
	return nil
}

type Bootstrap struct {
	Addresses map[uint64]string `protobuf:"bytes,1,rep,name=addresses" json:"addresses,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	Join      bool              `protobuf:"varint,2,opt,name=join" json:"join"`
}

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

var xxx_messageInfo_Bootstrap proto.InternalMessageInfo

func (m *Bootstrap) GetAddresses() map[uint64]string {
	if m != nil {
		return m.Addresses
	}
	return nil
}

func (m *Bootstrap) GetJoin() bool {
	if m != nil {
		return m.Join
	}
	return false
}

type EntryBatch struct {
	Entries []Entry `protobuf:"bytes,1,rep,name=entries" json:"entries"`
}

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

var xxx_messageInfo_EntryBatch proto.InternalMessageInfo

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

type BallotNumber struct {
	ProposalID uint64 `protobuf:"varint,1,opt,name=ProposalID,json=proposalID" json:"ProposalID"`
	NodeID     uint64 `protobuf:"varint,2,opt,name=NodeID,json=nodeID" json:"NodeID"`
}

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

var xxx_messageInfo_BallotNumber proto.InternalMessageInfo

func (m *BallotNumber) GetProposalID() uint64 {
	if m != nil {
		return m.ProposalID
	}
	return 0
}

func (m *BallotNumber) GetNodeID() uint64 {
	if m != nil {
		return m.NodeID
	}
	return 0
}

type AcceptorState struct {
	InstanceID     uint64       `protobuf:"varint,1,opt,name=InstanceID,json=instanceID" json:"InstanceID"`
	PromiseBallot  BallotNumber `protobuf:"bytes,2,opt,name=PromiseBallot,json=promiseBallot" json:"PromiseBallot"`
	AcceptedBallot BallotNumber `protobuf:"bytes,3,opt,name=AcceptedBallot,json=acceptedBallot" json:"AcceptedBallot"`
	AccetpedValue  []byte       `protobuf:"bytes,4,opt,name=AccetpedValue,json=accetpedValue" json:"AccetpedValue"`
}

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

var xxx_messageInfo_AcceptorState proto.InternalMessageInfo

func (m *AcceptorState) GetInstanceID() uint64 {
	if m != nil {
		return m.InstanceID
	}
	return 0
}

func (m *AcceptorState) GetPromiseBallot() BallotNumber {
	if m != nil {
		return m.PromiseBallot
	}
	return BallotNumber{}
}

func (m *AcceptorState) GetAcceptedBallot() BallotNumber {
	if m != nil {
		return m.AcceptedBallot
	}
	return BallotNumber{}
}

func (m *AcceptorState) GetAccetpedValue() []byte {
	if m != nil {
		return m.AccetpedValue
	}
	return nil
}

type SnapshotHeader struct {
	DataStoreSize   uint64       `protobuf:"varint,1,opt,name=data_store_size,json=dataStoreSize" json:"data_store_size"`
	UnreliableTime  uint64       `protobuf:"varint,2,opt,name=unreliable_time,json=unreliableTime" json:"unreliable_time"`
	GitVersion      string       `protobuf:"bytes,3,opt,name=git_version,json=gitVersion" json:"git_version"`
	HeaderChecksum  []byte       `protobuf:"bytes,4,opt,name=header_checksum,json=headerChecksum" json:"header_checksum"`
	PayloadChecksum []byte       `protobuf:"bytes,5,opt,name=payload_checksum,json=payloadChecksum" json:"payload_checksum"`
	ChecksumType    ChecksumType `protobuf:"varint,6,opt,name=checksum_type,json=checksumType,enum=paxospb.ChecksumType" json:"checksum_type"`
	Version         uint64       `protobuf:"varint,7,opt,name=version" json:"version"`
}

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

var xxx_messageInfo_SnapshotHeader proto.InternalMessageInfo

func (m *SnapshotHeader) GetDataStoreSize() uint64 {
	if m != nil {
		return m.DataStoreSize
	}
	return 0
}

func (m *SnapshotHeader) GetUnreliableTime() uint64 {
	if m != nil {
		return m.UnreliableTime
	}
	return 0
}

func (m *SnapshotHeader) GetGitVersion() string {
	if m != nil {
		return m.GitVersion
	}
	return ""
}

func (m *SnapshotHeader) GetHeaderChecksum() []byte {
	if m != nil {
		return m.HeaderChecksum
	}
	return nil
}

func (m *SnapshotHeader) GetPayloadChecksum() []byte {
	if m != nil {
		return m.PayloadChecksum
	}
	return nil
}

func (m *SnapshotHeader) GetChecksumType() ChecksumType {
	if m != nil {
		return m.ChecksumType
	}
	return CRC32IEEE
}

func (m *SnapshotHeader) GetVersion() uint64 {
	if m != nil {
		return m.Version
	}
	return 0
}

func init() {
	proto.RegisterEnum("paxospb.MessageType", MessageType_name, MessageType_value)
	proto.RegisterEnum("paxospb.EntryType", EntryType_name, EntryType_value)
	proto.RegisterEnum("paxospb.ChecksumType", ChecksumType_name, ChecksumType_value)
	proto.RegisterType((*PaxosDataStatus)(nil), "paxospb.PaxosDataStatus")
	proto.RegisterType((*PaxosMsg)(nil), "paxospb.PaxosMsg")
	proto.RegisterType((*MessageBatch)(nil), "paxospb.MessageBatch")
	proto.RegisterType((*State)(nil), "paxospb.State")
	proto.RegisterType((*Entry)(nil), "paxospb.Entry")
	proto.RegisterType((*Membership)(nil), "paxospb.Membership")
	proto.RegisterMapType((map[uint64]string)(nil), "paxospb.Membership.AddressesEntry")
	proto.RegisterMapType((map[uint64]bool)(nil), "paxospb.Membership.RemovedEntry")
	proto.RegisterType((*Bootstrap)(nil), "paxospb.Bootstrap")
	proto.RegisterMapType((map[uint64]string)(nil), "paxospb.Bootstrap.AddressesEntry")
	proto.RegisterType((*EntryBatch)(nil), "paxospb.EntryBatch")
	proto.RegisterType((*BallotNumber)(nil), "paxospb.BallotNumber")
	proto.RegisterType((*AcceptorState)(nil), "paxospb.AcceptorState")
	proto.RegisterType((*SnapshotHeader)(nil), "paxospb.SnapshotHeader")
}

func init() { proto.RegisterFile("paxos.proto", fileDescriptor_fec356ed5fe8331d) }

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

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

func (m *PaxosDataStatus) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(len(m.Address)))
	i += copy(dAtA[i:], m.Address)
	dAtA[i] = 0x10
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.BinVer))
	dAtA[i] = 0x18
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.HardHash))
	return i, nil
}

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

func (m *PaxosMsg) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.MsgType))
	dAtA[i] = 0x10
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.To))
	dAtA[i] = 0x18
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.From))
	dAtA[i] = 0x20
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.GroupID))
	dAtA[i] = 0x28
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.InstanceID))
	dAtA[i] = 0x30
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.ProposalID))
	dAtA[i] = 0x38
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.ProposalNodeID))
	if m.Value != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintPaxos(dAtA, i, uint64(len(m.Value)))
		i += copy(dAtA[i:], m.Value)
	}
	dAtA[i] = 0x48
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.PreAcceptID))
	dAtA[i] = 0x50
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.PreAcceptNodeID))
	dAtA[i] = 0x58
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.RejectByPromiseID))
	dAtA[i] = 0x60
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.NowInstanceID))
	dAtA[i] = 0x68
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.MinChosenInstanceID))
	dAtA[i] = 0x70
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.Flag))
	dAtA[i] = 0x78
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.Key))
	return i, nil
}

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

func (m *MessageBatch) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Requests) > 0 {
		for _, msg := range m.Requests {
			dAtA[i] = 0xa
			i++
			i = encodeVarintPaxos(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(len(m.SourceAddress)))
	i += copy(dAtA[i:], m.SourceAddress)
	dAtA[i] = 0x18
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.BinVer))
	return i, nil
}

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

func (m *State) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.Commit))
	dAtA[i] = 0x12
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.AcceptorState.Size()))
	n1, err1 := m.AcceptorState.MarshalTo(dAtA[i:])
	if err1 != nil {
		return 0, err1
	}
	i += n1
	return i, nil
}

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

func (m *Entry) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.Type))
	dAtA[i] = 0x10
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.Key))
	dAtA[i] = 0x1a
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.AcceptorState.Size()))
	n2, err2 := m.AcceptorState.MarshalTo(dAtA[i:])
	if err2 != nil {
		return 0, err2
	}
	i += n2
	return i, nil
}

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

func (m *Membership) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.ConfigChangeId))
	if len(m.Addresses) > 0 {
		for k, _ := range m.Addresses {
			dAtA[i] = 0x12
			i++
			v := m.Addresses[k]
			mapSize := 1 + sovPaxos(uint64(k)) + 1 + len(v) + sovPaxos(uint64(len(v)))
			i = encodeVarintPaxos(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintPaxos(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintPaxos(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	if len(m.Removed) > 0 {
		for k, _ := range m.Removed {
			dAtA[i] = 0x1a
			i++
			v := m.Removed[k]
			mapSize := 1 + sovPaxos(uint64(k)) + 1 + 1
			i = encodeVarintPaxos(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintPaxos(dAtA, i, uint64(k))
			dAtA[i] = 0x10
			i++
			if v {
				dAtA[i] = 1
			} else {
				dAtA[i] = 0
			}
			i++
		}
	}
	return i, nil
}

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

func (m *Bootstrap) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for k, _ := range m.Addresses {
			dAtA[i] = 0xa
			i++
			v := m.Addresses[k]
			mapSize := 1 + sovPaxos(uint64(k)) + 1 + len(v) + sovPaxos(uint64(len(v)))
			i = encodeVarintPaxos(dAtA, i, uint64(mapSize))
			dAtA[i] = 0x8
			i++
			i = encodeVarintPaxos(dAtA, i, uint64(k))
			dAtA[i] = 0x12
			i++
			i = encodeVarintPaxos(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	dAtA[i] = 0x10
	i++
	if m.Join {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	return i, nil
}

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

func (m *EntryBatch) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, msg := range m.Entries {
			dAtA[i] = 0xa
			i++
			i = encodeVarintPaxos(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *BallotNumber) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.ProposalID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.NodeID))
	return i, nil
}

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

func (m *AcceptorState) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.InstanceID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.PromiseBallot.Size()))
	n3, err3 := m.PromiseBallot.MarshalTo(dAtA[i:])
	if err3 != nil {
		return 0, err3
	}
	i += n3
	dAtA[i] = 0x1a
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.AcceptedBallot.Size()))
	n4, err4 := m.AcceptedBallot.MarshalTo(dAtA[i:])
	if err4 != nil {
		return 0, err4
	}
	i += n4
	if m.AccetpedValue != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintPaxos(dAtA, i, uint64(len(m.AccetpedValue)))
		i += copy(dAtA[i:], m.AccetpedValue)
	}
	return i, nil
}

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

func (m *SnapshotHeader) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.DataStoreSize))
	dAtA[i] = 0x10
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.UnreliableTime))
	dAtA[i] = 0x1a
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(len(m.GitVersion)))
	i += copy(dAtA[i:], m.GitVersion)
	if m.HeaderChecksum != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintPaxos(dAtA, i, uint64(len(m.HeaderChecksum)))
		i += copy(dAtA[i:], m.HeaderChecksum)
	}
	if m.PayloadChecksum != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintPaxos(dAtA, i, uint64(len(m.PayloadChecksum)))
		i += copy(dAtA[i:], m.PayloadChecksum)
	}
	dAtA[i] = 0x30
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.ChecksumType))
	dAtA[i] = 0x38
	i++
	i = encodeVarintPaxos(dAtA, i, uint64(m.Version))
	return i, nil
}

func encodeVarintPaxos(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *PaxosDataStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	n += 1 + l + sovPaxos(uint64(l))
	n += 1 + sovPaxos(uint64(m.BinVer))
	n += 1 + sovPaxos(uint64(m.HardHash))
	return n
}

func (m *PaxosMsg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPaxos(uint64(m.MsgType))
	n += 1 + sovPaxos(uint64(m.To))
	n += 1 + sovPaxos(uint64(m.From))
	n += 1 + sovPaxos(uint64(m.GroupID))
	n += 1 + sovPaxos(uint64(m.InstanceID))
	n += 1 + sovPaxos(uint64(m.ProposalID))
	n += 1 + sovPaxos(uint64(m.ProposalNodeID))
	if m.Value != nil {
		l = len(m.Value)
		n += 1 + l + sovPaxos(uint64(l))
	}
	n += 1 + sovPaxos(uint64(m.PreAcceptID))
	n += 1 + sovPaxos(uint64(m.PreAcceptNodeID))
	n += 1 + sovPaxos(uint64(m.RejectByPromiseID))
	n += 1 + sovPaxos(uint64(m.NowInstanceID))
	n += 1 + sovPaxos(uint64(m.MinChosenInstanceID))
	n += 1 + sovPaxos(uint64(m.Flag))
	n += 1 + sovPaxos(uint64(m.Key))
	return n
}

func (m *MessageBatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Requests) > 0 {
		for _, e := range m.Requests {
			l = e.Size()
			n += 1 + l + sovPaxos(uint64(l))
		}
	}
	l = len(m.SourceAddress)
	n += 1 + l + sovPaxos(uint64(l))
	n += 1 + sovPaxos(uint64(m.BinVer))
	return n
}

func (m *State) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPaxos(uint64(m.Commit))
	l = m.AcceptorState.Size()
	n += 1 + l + sovPaxos(uint64(l))
	return n
}

func (m *Entry) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPaxos(uint64(m.Type))
	n += 1 + sovPaxos(uint64(m.Key))
	l = m.AcceptorState.Size()
	n += 1 + l + sovPaxos(uint64(l))
	return n
}

func (m *Membership) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPaxos(uint64(m.ConfigChangeId))
	if len(m.Addresses) > 0 {
		for k, v := range m.Addresses {
			_ = k
			_ = v
			mapEntrySize := 1 + sovPaxos(uint64(k)) + 1 + len(v) + sovPaxos(uint64(len(v)))
			n += mapEntrySize + 1 + sovPaxos(uint64(mapEntrySize))
		}
	}
	if len(m.Removed) > 0 {
		for k, v := range m.Removed {
			_ = k
			_ = v
			mapEntrySize := 1 + sovPaxos(uint64(k)) + 1 + 1
			n += mapEntrySize + 1 + sovPaxos(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *Bootstrap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Addresses) > 0 {
		for k, v := range m.Addresses {
			_ = k
			_ = v
			mapEntrySize := 1 + sovPaxos(uint64(k)) + 1 + len(v) + sovPaxos(uint64(len(v)))
			n += mapEntrySize + 1 + sovPaxos(uint64(mapEntrySize))
		}
	}
	n += 2
	return n
}

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

func (m *BallotNumber) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPaxos(uint64(m.ProposalID))
	n += 1 + sovPaxos(uint64(m.NodeID))
	return n
}

func (m *AcceptorState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPaxos(uint64(m.InstanceID))
	l = m.PromiseBallot.Size()
	n += 1 + l + sovPaxos(uint64(l))
	l = m.AcceptedBallot.Size()
	n += 1 + l + sovPaxos(uint64(l))
	if m.AccetpedValue != nil {
		l = len(m.AccetpedValue)
		n += 1 + l + sovPaxos(uint64(l))
	}
	return n
}

func (m *SnapshotHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovPaxos(uint64(m.DataStoreSize))
	n += 1 + sovPaxos(uint64(m.UnreliableTime))
	l = len(m.GitVersion)
	n += 1 + l + sovPaxos(uint64(l))
	if m.HeaderChecksum != nil {
		l = len(m.HeaderChecksum)
		n += 1 + l + sovPaxos(uint64(l))
	}
	if m.PayloadChecksum != nil {
		l = len(m.PayloadChecksum)
		n += 1 + l + sovPaxos(uint64(l))
	}
	n += 1 + sovPaxos(uint64(m.ChecksumType))
	n += 1 + sovPaxos(uint64(m.Version))
	return n
}

func sovPaxos(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozPaxos(x uint64) (n int) {
	return sovPaxos(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *PaxosDataStatus) 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 ErrIntOverflowPaxos
			}
			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: PaxosDataStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PaxosDataStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				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 ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinVer", wireType)
			}
			m.BinVer = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BinVer |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HardHash", wireType)
			}
			m.HardHash = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.HardHash |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPaxos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PaxosMsg) 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 ErrIntOverflowPaxos
			}
			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: PaxosMsg: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PaxosMsg: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MsgType", wireType)
			}
			m.MsgType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MsgType |= MessageType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			m.To = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.To |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			m.From = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.From |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupID", wireType)
			}
			m.GroupID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GroupID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
			}
			m.InstanceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InstanceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalID", wireType)
			}
			m.ProposalID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposalNodeID", wireType)
			}
			m.ProposalNodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposalNodeID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
			if m.Value == nil {
				m.Value = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreAcceptID", wireType)
			}
			m.PreAcceptID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PreAcceptID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreAcceptNodeID", wireType)
			}
			m.PreAcceptNodeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PreAcceptNodeID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RejectByPromiseID", wireType)
			}
			m.RejectByPromiseID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RejectByPromiseID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NowInstanceID", wireType)
			}
			m.NowInstanceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NowInstanceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinChosenInstanceID", wireType)
			}
			m.MinChosenInstanceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MinChosenInstanceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flag", wireType)
			}
			m.Flag = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Flag |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			m.Key = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Key |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPaxos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MessageBatch) 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 ErrIntOverflowPaxos
			}
			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: MessageBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageBatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Requests", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requests = append(m.Requests, PaxosMsg{})
			if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				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 ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SourceAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BinVer", wireType)
			}
			m.BinVer = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BinVer |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPaxos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Entry) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowPaxos
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Entry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= EntryType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			m.Key = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Key |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AcceptorState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AcceptorState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPaxos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Membership) 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 ErrIntOverflowPaxos
			}
			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: Membership: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Membership: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigChangeId", wireType)
			}
			m.ConfigChangeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConfigChangeId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Addresses == nil {
				m.Addresses = make(map[uint64]string)
			}
			var mapkey uint64
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowPaxos
					}
					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 ErrIntOverflowPaxos
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowPaxos
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthPaxos
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthPaxos
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipPaxos(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthPaxos
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Addresses[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Removed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Removed == nil {
				m.Removed = make(map[uint64]bool)
			}
			var mapkey uint64
			var mapvalue bool
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowPaxos
					}
					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 ErrIntOverflowPaxos
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapvaluetemp int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowPaxos
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvaluetemp |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					mapvalue = bool(mapvaluetemp != 0)
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipPaxos(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthPaxos
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Removed[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPaxos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Bootstrap) 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 ErrIntOverflowPaxos
			}
			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: Bootstrap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Bootstrap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Addresses == nil {
				m.Addresses = make(map[uint64]string)
			}
			var mapkey uint64
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowPaxos
					}
					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 ErrIntOverflowPaxos
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowPaxos
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthPaxos
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthPaxos
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipPaxos(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthPaxos
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Addresses[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Join", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Join = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipPaxos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AcceptorState) 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 ErrIntOverflowPaxos
			}
			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: AcceptorState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AcceptorState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceID", wireType)
			}
			m.InstanceID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.InstanceID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PromiseBallot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PromiseBallot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AcceptedBallot", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.AcceptedBallot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccetpedValue", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccetpedValue = append(m.AccetpedValue[:0], dAtA[iNdEx:postIndex]...)
			if m.AccetpedValue == nil {
				m.AccetpedValue = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPaxos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SnapshotHeader) 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 ErrIntOverflowPaxos
			}
			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: SnapshotHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SnapshotHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataStoreSize", wireType)
			}
			m.DataStoreSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DataStoreSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnreliableTime", wireType)
			}
			m.UnreliableTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UnreliableTime |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GitVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				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 ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GitVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeaderChecksum", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeaderChecksum = append(m.HeaderChecksum[:0], dAtA[iNdEx:postIndex]...)
			if m.HeaderChecksum == nil {
				m.HeaderChecksum = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayloadChecksum", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPaxos
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPaxos
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PayloadChecksum = append(m.PayloadChecksum[:0], dAtA[iNdEx:postIndex]...)
			if m.PayloadChecksum == nil {
				m.PayloadChecksum = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChecksumType", wireType)
			}
			m.ChecksumType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChecksumType |= ChecksumType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPaxos
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipPaxos(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthPaxos
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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