error.pb.go

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

package multiraftbase

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import bytes "bytes"

import io "io"

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

// A NodeUnavailableError indicates that the sending gateway can
// not process requests at the time, and that the client should
// retry the request with another peer.
type NodeUnavailableError struct {
}

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

// A RangeNotFoundError indicates that a command was sent to a range
// which is not hosted on this store.
type PgNotFoundError struct {
	PgName string `protobuf:"bytes,1,opt,name=pg_name,json=pgName,proto3" json:"pg_name,omitempty"`
}

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

func (m *PgNotFoundError) GetPgName() string {
	if m != nil {
		return m.PgName
	}
	return ""
}

// A SendError indicates that a message could not be delivered to
// the desired recipient(s).
type SendError struct {
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
}

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

func (m *SendError) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

// An AmbiguousResultError indicates that a request may have succeeded or
// failed, but the response was not received and the final result is ambiguous.
type AmbiguousResultError struct {
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	// This can be set to give extra information about which error was converted
	// into an AmbiguousResultError. Useful for tests.
	WrappedErr *Error `protobuf:"bytes,2,opt,name=wrapped_err,json=wrappedErr" json:"wrapped_err,omitempty"`
}

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

func (m *AmbiguousResultError) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *AmbiguousResultError) GetWrappedErr() *Error {
	if m != nil {
		return m.WrappedErr
	}
	return nil
}

// A RaftGroupDeletedError indicates a raft group has been deleted for
// the replica.
type RaftGroupDeletedError struct {
}

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

// A ReplicaCorruptionError indicates that the replica has experienced
// an error which puts its integrity at risk.
type ReplicaCorruptionError struct {
	ErrorMsg string `protobuf:"bytes,1,opt,name=error_msg,json=errorMsg,proto3" json:"error_msg,omitempty"`
	// processed indicates that the error has been taken into account and
	// necessary steps will be taken. For now, required for testing.
	Processed bool `protobuf:"varint,2,opt,name=processed,proto3" json:"processed,omitempty"`
}

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

func (m *ReplicaCorruptionError) GetErrorMsg() string {
	if m != nil {
		return m.ErrorMsg
	}
	return ""
}

func (m *ReplicaCorruptionError) GetProcessed() bool {
	if m != nil {
		return m.Processed
	}
	return false
}

// ReplicaTooOldError is sent in response to a raft message when the
// recipient of the raft message believes the sender of the raft
// message to have been removed from the raft group
type ReplicaTooOldError struct {
	// replica_id is the ID of the replica that is too old.
	ReplicaID ReplicaID `protobuf:"varint,1,opt,name=replica_id,json=replicaId,proto3,casttype=ReplicaID" json:"replica_id,omitempty"`
}

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

func (m *ReplicaTooOldError) GetReplicaID() ReplicaID {
	if m != nil {
		return m.ReplicaID
	}
	return 0
}

type NodeNotReadyError struct {
	NodeID NodeID `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3,casttype=NodeID" json:"node_id,omitempty"`
}

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

func (m *NodeNotReadyError) GetNodeID() NodeID {
	if m != nil {
		return m.NodeID
	}
	return ""
}

// A GroupNotFoundError indicates that a command was sent to a range
// which is not hosted on this store.
type GroupNotFoundError struct {
	GroupID GroupID `protobuf:"bytes,1,opt,name=group_id,json=groupId,proto3,casttype=GroupID" json:"group_id,omitempty"`
}

func (m *GroupNotFoundError) Reset()                    { *m = GroupNotFoundError{} }
func (m *GroupNotFoundError) String() string            { return proto.CompactTextString(m) }
func (*GroupNotFoundError) ProtoMessage()               {}
func (*GroupNotFoundError) Descriptor() ([]byte, []int) { return fileDescriptorError, []int{8} }

func (m *GroupNotFoundError) GetGroupID() GroupID {
	if m != nil {
		return m.GroupID
	}
	return ""
}

// A GroupNotFoundError indicates that a command was sent to a range
// which is not hosted on this store.
type KeyNonExistent struct {
	Key Key `protobuf:"bytes,1,opt,name=key,proto3,casttype=Key" json:"key,omitempty"`
}

func (m *KeyNonExistent) Reset()                    { *m = KeyNonExistent{} }
func (m *KeyNonExistent) String() string            { return proto.CompactTextString(m) }
func (*KeyNonExistent) ProtoMessage()               {}
func (*KeyNonExistent) Descriptor() ([]byte, []int) { return fileDescriptorError, []int{9} }

func (m *KeyNonExistent) GetKey() Key {
	if m != nil {
		return m.Key
	}
	return nil
}

type OnodeBroken struct {
	Key Key `protobuf:"bytes,1,opt,name=key,proto3,casttype=Key" json:"key,omitempty"`
}

func (m *OnodeBroken) Reset()                    { *m = OnodeBroken{} }
func (m *OnodeBroken) String() string            { return proto.CompactTextString(m) }
func (*OnodeBroken) ProtoMessage()               {}
func (*OnodeBroken) Descriptor() ([]byte, []int) { return fileDescriptorError, []int{10} }

func (m *OnodeBroken) GetKey() Key {
	if m != nil {
		return m.Key
	}
	return nil
}

type DataLost struct {
	Key Key `protobuf:"bytes,1,opt,name=key,proto3,casttype=Key" json:"key,omitempty"`
}

func (m *DataLost) Reset()                    { *m = DataLost{} }
func (m *DataLost) String() string            { return proto.CompactTextString(m) }
func (*DataLost) ProtoMessage()               {}
func (*DataLost) Descriptor() ([]byte, []int) { return fileDescriptorError, []int{11} }

func (m *DataLost) GetKey() Key {
	if m != nil {
		return m.Key
	}
	return nil
}

// A StoreNotFoundError indicates that a command was sent to a store
// which is not hosted on this node.
type StoreNotFoundError struct {
	StoreID StoreID `protobuf:"varint,1,opt,name=store_id,json=storeId,proto3,casttype=StoreID" json:"store_id,omitempty"`
}

func (m *StoreNotFoundError) Reset()                    { *m = StoreNotFoundError{} }
func (m *StoreNotFoundError) String() string            { return proto.CompactTextString(m) }
func (*StoreNotFoundError) ProtoMessage()               {}
func (*StoreNotFoundError) Descriptor() ([]byte, []int) { return fileDescriptorError, []int{12} }

func (m *StoreNotFoundError) GetStoreID() StoreID {
	if m != nil {
		return m.StoreID
	}
	return 0
}

// ErrorDetail is a union type containing all available errors.
type ErrorDetail struct {
	NodeUnavailable *NodeUnavailableError `protobuf:"bytes,1,opt,name=node_unavailable,json=nodeUnavailable" json:"node_unavailable,omitempty"`
	NodeNotReady    *NodeNotReadyError    `protobuf:"bytes,2,opt,name=node_not_ready,json=nodeNotReady" json:"node_not_ready,omitempty"`
	Send            *SendError            `protobuf:"bytes,3,opt,name=send" json:"send,omitempty"`
	// TODO(kaneda): Following three are added to preserve the type when
	// converting Go errors from/to proto Errors. Revisit this design.
	RaftGroupDeleted  *RaftGroupDeletedError  `protobuf:"bytes,4,opt,name=raft_group_deleted,json=raftGroupDeleted" json:"raft_group_deleted,omitempty"`
	ReplicaCorruption *ReplicaCorruptionError `protobuf:"bytes,5,opt,name=replica_corruption,json=replicaCorruption" json:"replica_corruption,omitempty"`
	ReplicaTooOld     *ReplicaTooOldError     `protobuf:"bytes,6,opt,name=replica_too_old,json=replicaTooOld" json:"replica_too_old,omitempty"`
	AmbiguousResult   *AmbiguousResultError   `protobuf:"bytes,8,opt,name=ambiguous_result,json=ambiguousResult" json:"ambiguous_result,omitempty"`
	GroupNotFound     *GroupNotFoundError     `protobuf:"bytes,9,opt,name=group_not_found,json=groupNotFound" json:"group_not_found,omitempty"`
	KeyNonExistent    *KeyNonExistent         `protobuf:"bytes,10,opt,name=key_non_existent,json=keyNonExistent" json:"key_non_existent,omitempty"`
}

func (m *ErrorDetail) Reset()                    { *m = ErrorDetail{} }
func (m *ErrorDetail) String() string            { return proto.CompactTextString(m) }
func (*ErrorDetail) ProtoMessage()               {}
func (*ErrorDetail) Descriptor() ([]byte, []int) { return fileDescriptorError, []int{13} }

func (m *ErrorDetail) GetNodeUnavailable() *NodeUnavailableError {
	if m != nil {
		return m.NodeUnavailable
	}
	return nil
}

func (m *ErrorDetail) GetNodeNotReady() *NodeNotReadyError {
	if m != nil {
		return m.NodeNotReady
	}
	return nil
}

func (m *ErrorDetail) GetSend() *SendError {
	if m != nil {
		return m.Send
	}
	return nil
}

func (m *ErrorDetail) GetRaftGroupDeleted() *RaftGroupDeletedError {
	if m != nil {
		return m.RaftGroupDeleted
	}
	return nil
}

func (m *ErrorDetail) GetReplicaCorruption() *ReplicaCorruptionError {
	if m != nil {
		return m.ReplicaCorruption
	}
	return nil
}

func (m *ErrorDetail) GetReplicaTooOld() *ReplicaTooOldError {
	if m != nil {
		return m.ReplicaTooOld
	}
	return nil
}

func (m *ErrorDetail) GetAmbiguousResult() *AmbiguousResultError {
	if m != nil {
		return m.AmbiguousResult
	}
	return nil
}

func (m *ErrorDetail) GetGroupNotFound() *GroupNotFoundError {
	if m != nil {
		return m.GroupNotFound
	}
	return nil
}

func (m *ErrorDetail) GetKeyNonExistent() *KeyNonExistent {
	if m != nil {
		return m.KeyNonExistent
	}
	return nil
}

// ErrPosition describes the position of an error in a Batch. A simple nullable
// primitive field would break compatibility with proto3, where primitive fields
// are no longer allowed to be nullable.
type ErrPosition struct {
	Index int32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
}

func (m *ErrPosition) Reset()                    { *m = ErrPosition{} }
func (m *ErrPosition) String() string            { return proto.CompactTextString(m) }
func (*ErrPosition) ProtoMessage()               {}
func (*ErrPosition) Descriptor() ([]byte, []int) { return fileDescriptorError, []int{14} }

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

// Error is a generic representation including a string message
// and information about retryability.
type Error struct {
	// message is a human-readable error message.
	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
	// Node at which the error was generated (zero if does not apply).
	OriginNode string `protobuf:"bytes,2,opt,name=origin_node,json=originNode,proto3" json:"origin_node,omitempty"`
	// If an ErrorDetail is present, it may contain additional structured data
	// about the error.
	Detail *ErrorDetail `protobuf:"bytes,3,opt,name=detail" json:"detail,omitempty"`
	// The index, if given, contains the index of the request (in the batch)
	// whose execution caused the error.
	Index *ErrPosition `protobuf:"bytes,4,opt,name=index" json:"index,omitempty"`
}

func (m *Error) Reset()                    { *m = Error{} }
func (*Error) ProtoMessage()               {}
func (*Error) Descriptor() ([]byte, []int) { return fileDescriptorError, []int{15} }

func (m *Error) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *Error) GetOriginNode() string {
	if m != nil {
		return m.OriginNode
	}
	return ""
}

func (m *Error) GetDetail() *ErrorDetail {
	if m != nil {
		return m.Detail
	}
	return nil
}

func (m *Error) GetIndex() *ErrPosition {
	if m != nil {
		return m.Index
	}
	return nil
}

func init() {
	proto.RegisterType((*NodeUnavailableError)(nil), "multiraftbase.NodeUnavailableError")
	proto.RegisterType((*PgNotFoundError)(nil), "multiraftbase.PgNotFoundError")
	proto.RegisterType((*SendError)(nil), "multiraftbase.SendError")
	proto.RegisterType((*AmbiguousResultError)(nil), "multiraftbase.AmbiguousResultError")
	proto.RegisterType((*RaftGroupDeletedError)(nil), "multiraftbase.RaftGroupDeletedError")
	proto.RegisterType((*ReplicaCorruptionError)(nil), "multiraftbase.ReplicaCorruptionError")
	proto.RegisterType((*ReplicaTooOldError)(nil), "multiraftbase.ReplicaTooOldError")
	proto.RegisterType((*NodeNotReadyError)(nil), "multiraftbase.NodeNotReadyError")
	proto.RegisterType((*GroupNotFoundError)(nil), "multiraftbase.GroupNotFoundError")
	proto.RegisterType((*KeyNonExistent)(nil), "multiraftbase.KeyNonExistent")
	proto.RegisterType((*OnodeBroken)(nil), "multiraftbase.OnodeBroken")
	proto.RegisterType((*DataLost)(nil), "multiraftbase.DataLost")
	proto.RegisterType((*StoreNotFoundError)(nil), "multiraftbase.StoreNotFoundError")
	proto.RegisterType((*ErrorDetail)(nil), "multiraftbase.ErrorDetail")
	proto.RegisterType((*ErrPosition)(nil), "multiraftbase.ErrPosition")
	proto.RegisterType((*Error)(nil), "multiraftbase.Error")
}
func (this *NodeUnavailableError) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

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

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

	that1, ok := that.(*AmbiguousResultError)
	if !ok {
		that2, ok := that.(AmbiguousResultError)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if !this.WrappedErr.Equal(that1.WrappedErr) {
		return false
	}
	return true
}
func (this *RaftGroupDeletedError) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

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

	that1, ok := that.(*ReplicaCorruptionError)
	if !ok {
		that2, ok := that.(ReplicaCorruptionError)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.ErrorMsg != that1.ErrorMsg {
		return false
	}
	if this.Processed != that1.Processed {
		return false
	}
	return true
}
func (this *ReplicaTooOldError) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

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

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

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

	that1, ok := that.(*KeyNonExistent)
	if !ok {
		that2, ok := that.(KeyNonExistent)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Key, that1.Key) {
		return false
	}
	return true
}
func (this *OnodeBroken) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*OnodeBroken)
	if !ok {
		that2, ok := that.(OnodeBroken)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Key, that1.Key) {
		return false
	}
	return true
}
func (this *DataLost) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*DataLost)
	if !ok {
		that2, ok := that.(DataLost)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Key, that1.Key) {
		return false
	}
	return true
}
func (this *StoreNotFoundError) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

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

	that1, ok := that.(*ErrorDetail)
	if !ok {
		that2, ok := that.(ErrorDetail)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.NodeUnavailable.Equal(that1.NodeUnavailable) {
		return false
	}
	if !this.NodeNotReady.Equal(that1.NodeNotReady) {
		return false
	}
	if !this.Send.Equal(that1.Send) {
		return false
	}
	if !this.RaftGroupDeleted.Equal(that1.RaftGroupDeleted) {
		return false
	}
	if !this.ReplicaCorruption.Equal(that1.ReplicaCorruption) {
		return false
	}
	if !this.ReplicaTooOld.Equal(that1.ReplicaTooOld) {
		return false
	}
	if !this.AmbiguousResult.Equal(that1.AmbiguousResult) {
		return false
	}
	if !this.GroupNotFound.Equal(that1.GroupNotFound) {
		return false
	}
	if !this.KeyNonExistent.Equal(that1.KeyNonExistent) {
		return false
	}
	return true
}
func (this *ErrPosition) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

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

	that1, ok := that.(*Error)
	if !ok {
		that2, ok := that.(Error)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Message != that1.Message {
		return false
	}
	if this.OriginNode != that1.OriginNode {
		return false
	}
	if !this.Detail.Equal(that1.Detail) {
		return false
	}
	if !this.Index.Equal(that1.Index) {
		return false
	}
	return true
}
func (m *NodeUnavailableError) 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 *NodeUnavailableError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *PgNotFoundError) 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 *PgNotFoundError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PgName) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.PgName)))
		i += copy(dAtA[i:], m.PgName)
	}
	return i, nil
}

func (m *SendError) 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 *SendError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	return i, nil
}

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

func (m *RaftGroupDeletedError) 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 *RaftGroupDeletedError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

func (m *ReplicaCorruptionError) 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 *ReplicaCorruptionError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ErrorMsg) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.ErrorMsg)))
		i += copy(dAtA[i:], m.ErrorMsg)
	}
	if m.Processed {
		dAtA[i] = 0x10
		i++
		if m.Processed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *ReplicaTooOldError) 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 *ReplicaTooOldError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ReplicaID != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintError(dAtA, i, uint64(m.ReplicaID))
	}
	return i, nil
}

func (m *NodeNotReadyError) 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 *NodeNotReadyError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.NodeID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.NodeID)))
		i += copy(dAtA[i:], m.NodeID)
	}
	return i, nil
}

func (m *GroupNotFoundError) 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 *GroupNotFoundError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.GroupID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.GroupID)))
		i += copy(dAtA[i:], m.GroupID)
	}
	return i, nil
}

func (m *KeyNonExistent) 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 *KeyNonExistent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	return i, nil
}

func (m *OnodeBroken) 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 *OnodeBroken) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	return i, nil
}

func (m *DataLost) 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 *DataLost) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Key) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.Key)))
		i += copy(dAtA[i:], m.Key)
	}
	return i, nil
}

func (m *StoreNotFoundError) 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 *StoreNotFoundError) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.StoreID != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintError(dAtA, i, uint64(m.StoreID))
	}
	return i, nil
}

func (m *ErrorDetail) 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 *ErrorDetail) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.NodeUnavailable != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(m.NodeUnavailable.Size()))
		n2, err := m.NodeUnavailable.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.NodeNotReady != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintError(dAtA, i, uint64(m.NodeNotReady.Size()))
		n3, err := m.NodeNotReady.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Send != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintError(dAtA, i, uint64(m.Send.Size()))
		n4, err := m.Send.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.RaftGroupDeleted != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintError(dAtA, i, uint64(m.RaftGroupDeleted.Size()))
		n5, err := m.RaftGroupDeleted.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.ReplicaCorruption != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintError(dAtA, i, uint64(m.ReplicaCorruption.Size()))
		n6, err := m.ReplicaCorruption.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.ReplicaTooOld != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintError(dAtA, i, uint64(m.ReplicaTooOld.Size()))
		n7, err := m.ReplicaTooOld.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.AmbiguousResult != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintError(dAtA, i, uint64(m.AmbiguousResult.Size()))
		n8, err := m.AmbiguousResult.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.GroupNotFound != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintError(dAtA, i, uint64(m.GroupNotFound.Size()))
		n9, err := m.GroupNotFound.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.KeyNonExistent != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintError(dAtA, i, uint64(m.KeyNonExistent.Size()))
		n10, err := m.KeyNonExistent.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	return i, nil
}

func (m *ErrPosition) 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 *ErrPosition) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintError(dAtA, i, uint64(m.Index))
	}
	return i, nil
}

func (m *Error) 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 *Error) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Message) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.Message)))
		i += copy(dAtA[i:], m.Message)
	}
	if len(m.OriginNode) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintError(dAtA, i, uint64(len(m.OriginNode)))
		i += copy(dAtA[i:], m.OriginNode)
	}
	if m.Detail != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintError(dAtA, i, uint64(m.Detail.Size()))
		n11, err := m.Detail.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.Index != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintError(dAtA, i, uint64(m.Index.Size()))
		n12, err := m.Index.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}

func encodeFixed64Error(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Error(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintError(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 *NodeUnavailableError) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *PgNotFoundError) Size() (n int) {
	var l int
	_ = l
	l = len(m.PgName)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *SendError) Size() (n int) {
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *AmbiguousResultError) Size() (n int) {
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	if m.WrappedErr != nil {
		l = m.WrappedErr.Size()
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *RaftGroupDeletedError) Size() (n int) {
	var l int
	_ = l
	return n
}

func (m *ReplicaCorruptionError) Size() (n int) {
	var l int
	_ = l
	l = len(m.ErrorMsg)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	if m.Processed {
		n += 2
	}
	return n
}

func (m *ReplicaTooOldError) Size() (n int) {
	var l int
	_ = l
	if m.ReplicaID != 0 {
		n += 1 + sovError(uint64(m.ReplicaID))
	}
	return n
}

func (m *NodeNotReadyError) Size() (n int) {
	var l int
	_ = l
	l = len(m.NodeID)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *GroupNotFoundError) Size() (n int) {
	var l int
	_ = l
	l = len(m.GroupID)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *KeyNonExistent) Size() (n int) {
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *OnodeBroken) Size() (n int) {
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *DataLost) Size() (n int) {
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *StoreNotFoundError) Size() (n int) {
	var l int
	_ = l
	if m.StoreID != 0 {
		n += 1 + sovError(uint64(m.StoreID))
	}
	return n
}

func (m *ErrorDetail) Size() (n int) {
	var l int
	_ = l
	if m.NodeUnavailable != nil {
		l = m.NodeUnavailable.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.NodeNotReady != nil {
		l = m.NodeNotReady.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.Send != nil {
		l = m.Send.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.RaftGroupDeleted != nil {
		l = m.RaftGroupDeleted.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.ReplicaCorruption != nil {
		l = m.ReplicaCorruption.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.ReplicaTooOld != nil {
		l = m.ReplicaTooOld.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.AmbiguousResult != nil {
		l = m.AmbiguousResult.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.GroupNotFound != nil {
		l = m.GroupNotFound.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.KeyNonExistent != nil {
		l = m.KeyNonExistent.Size()
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func (m *ErrPosition) Size() (n int) {
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovError(uint64(m.Index))
	}
	return n
}

func (m *Error) Size() (n int) {
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	l = len(m.OriginNode)
	if l > 0 {
		n += 1 + l + sovError(uint64(l))
	}
	if m.Detail != nil {
		l = m.Detail.Size()
		n += 1 + l + sovError(uint64(l))
	}
	if m.Index != nil {
		l = m.Index.Size()
		n += 1 + l + sovError(uint64(l))
	}
	return n
}

func sovError(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozError(x uint64) (n int) {
	return sovError(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *ErrorDetail) GetValue() interface{} {
	if this.NodeUnavailable != nil {
		return this.NodeUnavailable
	}
	if this.NodeNotReady != nil {
		return this.NodeNotReady
	}
	if this.Send != nil {
		return this.Send
	}
	if this.RaftGroupDeleted != nil {
		return this.RaftGroupDeleted
	}
	if this.ReplicaCorruption != nil {
		return this.ReplicaCorruption
	}
	if this.ReplicaTooOld != nil {
		return this.ReplicaTooOld
	}
	if this.AmbiguousResult != nil {
		return this.AmbiguousResult
	}
	if this.GroupNotFound != nil {
		return this.GroupNotFound
	}
	if this.KeyNonExistent != nil {
		return this.KeyNonExistent
	}
	return nil
}

func (this *ErrorDetail) SetValue(value interface{}) bool {
	switch vt := value.(type) {
	case *NodeUnavailableError:
		this.NodeUnavailable = vt
	case *NodeNotReadyError:
		this.NodeNotReady = vt
	case *SendError:
		this.Send = vt
	case *RaftGroupDeletedError:
		this.RaftGroupDeleted = vt
	case *ReplicaCorruptionError:
		this.ReplicaCorruption = vt
	case *ReplicaTooOldError:
		this.ReplicaTooOld = vt
	case *AmbiguousResultError:
		this.AmbiguousResult = vt
	case *GroupNotFoundError:
		this.GroupNotFound = vt
	case *KeyNonExistent:
		this.KeyNonExistent = vt
	default:
		return false
	}
	return true
}
func (m *NodeUnavailableError) 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 ErrIntOverflowError
			}
			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: NodeUnavailableError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeUnavailableError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipError(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthError
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PgNotFoundError) 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 ErrIntOverflowError
			}
			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: PgNotFoundError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PgNotFoundError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PgName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				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 ErrInvalidLengthError
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PgName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipError(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthError
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SendError) 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 ErrIntOverflowError
			}
			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: SendError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SendError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				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 ErrInvalidLengthError
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipError(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthError
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RaftGroupDeletedError) 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 ErrIntOverflowError
			}
			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: RaftGroupDeletedError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftGroupDeletedError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipError(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthError
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeNotReadyError) 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 ErrIntOverflowError
			}
			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: NodeNotReadyError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeNotReadyError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				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 ErrInvalidLengthError
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeID = NodeID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipError(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthError
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GroupNotFoundError) 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 ErrIntOverflowError
			}
			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: GroupNotFoundError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GroupNotFoundError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				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 ErrInvalidLengthError
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupID = GroupID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipError(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthError
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ErrorDetail) 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 ErrIntOverflowError
			}
			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: ErrorDetail: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ErrorDetail: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeUnavailable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeUnavailable == nil {
				m.NodeUnavailable = &NodeUnavailableError{}
			}
			if err := m.NodeUnavailable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeNotReady", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NodeNotReady == nil {
				m.NodeNotReady = &NodeNotReadyError{}
			}
			if err := m.NodeNotReady.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Send", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Send == nil {
				m.Send = &SendError{}
			}
			if err := m.Send.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaftGroupDeleted", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RaftGroupDeleted == nil {
				m.RaftGroupDeleted = &RaftGroupDeletedError{}
			}
			if err := m.RaftGroupDeleted.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaCorruption", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReplicaCorruption == nil {
				m.ReplicaCorruption = &ReplicaCorruptionError{}
			}
			if err := m.ReplicaCorruption.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaTooOld", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReplicaTooOld == nil {
				m.ReplicaTooOld = &ReplicaTooOldError{}
			}
			if err := m.ReplicaTooOld.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AmbiguousResult", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AmbiguousResult == nil {
				m.AmbiguousResult = &AmbiguousResultError{}
			}
			if err := m.AmbiguousResult.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupNotFound", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GroupNotFound == nil {
				m.GroupNotFound = &GroupNotFoundError{}
			}
			if err := m.GroupNotFound.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyNonExistent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KeyNonExistent == nil {
				m.KeyNonExistent = &KeyNonExistent{}
			}
			if err := m.KeyNonExistent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipError(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthError
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Error) 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 ErrIntOverflowError
			}
			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: Error: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				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 ErrInvalidLengthError
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OriginNode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				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 ErrInvalidLengthError
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OriginNode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Detail", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Detail == nil {
				m.Detail = &ErrorDetail{}
			}
			if err := m.Detail.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowError
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthError
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Index == nil {
				m.Index = &ErrPosition{}
			}
			if err := m.Index.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipError(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthError
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipError(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, ErrIntOverflowError
			}
			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, ErrIntOverflowError
				}
				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, ErrIntOverflowError
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthError
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowError
					}
					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 := skipError(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

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

func init() { proto.RegisterFile("error.proto", fileDescriptorError) }

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