github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/pkg/kv/kvserver/raft.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: kv/kvserver/raft.proto

package kvserver

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import raftpb "go.etcd.io/etcd/raft/raftpb"
import kvserverpb "github.com/cockroachdb/cockroach/pkg/kv/kvserver/kvserverpb"
import roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"

import github_com_cockroachdb_cockroach_pkg_roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"

import io "io"

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

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

type SnapshotRequest_Priority int32

const (
	SnapshotRequest_UNKNOWN SnapshotRequest_Priority = 0
	// RECOVERY is used for a Raft-initiated snapshots and for
	// up-replication snapshots (i.e. when a dead node has been
	// removed and the range needs to be up-replicated).
	SnapshotRequest_RECOVERY SnapshotRequest_Priority = 1
	// REBALANCE is used for snapshots involved in rebalancing.
	SnapshotRequest_REBALANCE SnapshotRequest_Priority = 2
)

var SnapshotRequest_Priority_name = map[int32]string{
	0: "UNKNOWN",
	1: "RECOVERY",
	2: "REBALANCE",
}
var SnapshotRequest_Priority_value = map[string]int32{
	"UNKNOWN":   0,
	"RECOVERY":  1,
	"REBALANCE": 2,
}

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

type SnapshotRequest_Strategy int32

const (
	// KV_BATCH snapshots stream batches of KV pairs for all keys in a
	// range from the sender the the receiver. These KV pairs are then
	// combined into a large RocksDB WriteBatch that is atomically
	// applied.
	SnapshotRequest_KV_BATCH SnapshotRequest_Strategy = 0
)

var SnapshotRequest_Strategy_name = map[int32]string{
	0: "KV_BATCH",
}
var SnapshotRequest_Strategy_value = map[string]int32{
	"KV_BATCH": 0,
}

func (x SnapshotRequest_Strategy) Enum() *SnapshotRequest_Strategy {
	p := new(SnapshotRequest_Strategy)
	*p = x
	return p
}
func (x SnapshotRequest_Strategy) String() string {
	return proto.EnumName(SnapshotRequest_Strategy_name, int32(x))
}
func (x *SnapshotRequest_Strategy) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SnapshotRequest_Strategy_value, data, "SnapshotRequest_Strategy")
	if err != nil {
		return err
	}
	*x = SnapshotRequest_Strategy(value)
	return nil
}
func (SnapshotRequest_Strategy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_raft_3fc2b336b3beae43, []int{5, 1}
}

type SnapshotRequest_Type int32

const (
	SnapshotRequest_RAFT    SnapshotRequest_Type = 0
	SnapshotRequest_LEARNER SnapshotRequest_Type = 1
)

var SnapshotRequest_Type_name = map[int32]string{
	0: "RAFT",
	1: "LEARNER",
}
var SnapshotRequest_Type_value = map[string]int32{
	"RAFT":    0,
	"LEARNER": 1,
}

func (x SnapshotRequest_Type) Enum() *SnapshotRequest_Type {
	p := new(SnapshotRequest_Type)
	*p = x
	return p
}
func (x SnapshotRequest_Type) String() string {
	return proto.EnumName(SnapshotRequest_Type_name, int32(x))
}
func (x *SnapshotRequest_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SnapshotRequest_Type_value, data, "SnapshotRequest_Type")
	if err != nil {
		return err
	}
	*x = SnapshotRequest_Type(value)
	return nil
}
func (SnapshotRequest_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_raft_3fc2b336b3beae43, []int{5, 2}
}

type SnapshotResponse_Status int32

const (
	SnapshotResponse_UNKNOWN  SnapshotResponse_Status = 0
	SnapshotResponse_ACCEPTED SnapshotResponse_Status = 1
	SnapshotResponse_APPLIED  SnapshotResponse_Status = 2
	SnapshotResponse_ERROR    SnapshotResponse_Status = 3
	SnapshotResponse_DECLINED SnapshotResponse_Status = 4
)

var SnapshotResponse_Status_name = map[int32]string{
	0: "UNKNOWN",
	1: "ACCEPTED",
	2: "APPLIED",
	3: "ERROR",
	4: "DECLINED",
}
var SnapshotResponse_Status_value = map[string]int32{
	"UNKNOWN":  0,
	"ACCEPTED": 1,
	"APPLIED":  2,
	"ERROR":    3,
	"DECLINED": 4,
}

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

// RaftHeartbeat is a request that contains the barebones information for a
// raftpb.MsgHeartbeat raftpb.Message. RaftHeartbeats are coalesced and sent
// in a RaftMessageRequest, and reconstructed by the receiver into individual
// raftpb.Message protos.
type RaftHeartbeat struct {
	RangeID       github_com_cockroachdb_cockroach_pkg_roachpb.RangeID   `protobuf:"varint,1,opt,name=range_id,json=rangeId,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.RangeID" json:"range_id"`
	FromReplicaID github_com_cockroachdb_cockroach_pkg_roachpb.ReplicaID `protobuf:"varint,2,opt,name=from_replica_id,json=fromReplicaId,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.ReplicaID" json:"from_replica_id"`
	ToReplicaID   github_com_cockroachdb_cockroach_pkg_roachpb.ReplicaID `protobuf:"varint,3,opt,name=to_replica_id,json=toReplicaId,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.ReplicaID" json:"to_replica_id"`
	Term          uint64                                                 `protobuf:"varint,4,opt,name=term" json:"term"`
	Commit        uint64                                                 `protobuf:"varint,5,opt,name=commit" json:"commit"`
	Quiesce       bool                                                   `protobuf:"varint,6,opt,name=quiesce" json:"quiesce"`
	// ToIsLearner was added in v19.2 to aid in the transition from preemptive
	// snapshots to learner replicas. If a Replica learns its ID from a message
	// which indicates that it is a learner and it is not currently a part of the
	// range (due to being from a preemptive snapshot) then it must delete all of
	// its data.
	//
	// TODO(ajwerner): remove in 20.2 once we ensure that preemptive snapshots can
	// no longer be present and that we're never talking to a 19.2 node.
	ToIsLearner bool `protobuf:"varint,7,opt,name=to_is_learner,json=toIsLearner" json:"to_is_learner"`
}

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

var xxx_messageInfo_RaftHeartbeat proto.InternalMessageInfo

// RaftMessageRequest is the request used to send raft messages using our
// protobuf-based RPC codec. If a RaftMessageRequest has a non-empty number of
// heartbeats or heartbeat_resps, the contents of the message field is treated
// as a dummy message and discarded. A coalesced heartbeat request's replica
// descriptor's range ID must be zero.
type RaftMessageRequest struct {
	RangeID github_com_cockroachdb_cockroach_pkg_roachpb.RangeID `protobuf:"varint,1,opt,name=range_id,json=rangeId,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.RangeID" json:"range_id"`
	// Optionally, the start key of the sending replica. This is only populated
	// as a "hint" under certain conditions.
	RangeStartKey github_com_cockroachdb_cockroach_pkg_roachpb.RKey `protobuf:"bytes,8,opt,name=range_start_key,json=rangeStartKey,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.RKey" json:"range_start_key,omitempty"`
	FromReplica   roachpb.ReplicaDescriptor                         `protobuf:"bytes,2,opt,name=from_replica,json=fromReplica" json:"from_replica"`
	ToReplica     roachpb.ReplicaDescriptor                         `protobuf:"bytes,3,opt,name=to_replica,json=toReplica" json:"to_replica"`
	Message       raftpb.Message                                    `protobuf:"bytes,4,opt,name=message" json:"message"`
	// Is this a quiesce request? A quiesce request is a MsgHeartbeat
	// which is requesting the recipient to stop ticking its local
	// replica as long as the current Raft state matches the heartbeat
	// Term/Commit. If the Term/Commit match, the recipient is marked as
	// quiescent. If they don't match, the message is passed along to
	// Raft which will generate a MsgHeartbeatResp that will unquiesce
	// the sender.
	Quiesce bool `protobuf:"varint,5,opt,name=quiesce" json:"quiesce"`
	// A coalesced heartbeat request is any RaftMessageRequest with a nonzero number of
	// heartbeats or heartbeat_resps.
	Heartbeats     []RaftHeartbeat `protobuf:"bytes,6,rep,name=heartbeats" json:"heartbeats"`
	HeartbeatResps []RaftHeartbeat `protobuf:"bytes,7,rep,name=heartbeat_resps,json=heartbeatResps" json:"heartbeat_resps"`
}

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

var xxx_messageInfo_RaftMessageRequest proto.InternalMessageInfo

type RaftMessageRequestBatch struct {
	Requests []RaftMessageRequest `protobuf:"bytes,1,rep,name=requests" json:"requests"`
}

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

var xxx_messageInfo_RaftMessageRequestBatch proto.InternalMessageInfo

type RaftMessageResponseUnion struct {
	Error *roachpb.Error `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
}

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

var xxx_messageInfo_RaftMessageResponseUnion proto.InternalMessageInfo

// RaftMessageResponse may be sent to the sender of a
// RaftMessageRequest. RaftMessage does not use the usual
// request/response pattern; it is primarily modeled as a one-way
// stream of requests. Normal 'responses' are usually sent as new
// requests on a separate stream in the other direction.
// RaftMessageResponse is not sent for every RaftMessageRequest, but
// may be used for certain error conditions.
type RaftMessageResponse struct {
	RangeID     github_com_cockroachdb_cockroach_pkg_roachpb.RangeID `protobuf:"varint,1,opt,name=range_id,json=rangeId,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.RangeID" json:"range_id"`
	FromReplica roachpb.ReplicaDescriptor                            `protobuf:"bytes,2,opt,name=from_replica,json=fromReplica" json:"from_replica"`
	ToReplica   roachpb.ReplicaDescriptor                            `protobuf:"bytes,3,opt,name=to_replica,json=toReplica" json:"to_replica"`
	Union       RaftMessageResponseUnion                             `protobuf:"bytes,4,opt,name=union" json:"union"`
}

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

var xxx_messageInfo_RaftMessageResponse proto.InternalMessageInfo

// SnapshotRequest is the request used to send streaming snapshot requests.
type SnapshotRequest struct {
	Header *SnapshotRequest_Header `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
	// A RocksDB BatchRepr. Multiple kv_batches may be sent across multiple request messages.
	KVBatch []byte `protobuf:"bytes,2,opt,name=kv_batch,json=kvBatch" json:"kv_batch,omitempty"`
	// These are really raftpb.Entry, but we model them as raw bytes to avoid
	// roundtripping through memory. They are separate from the kv_batch to
	// allow flexibility in log implementations.
	LogEntries [][]byte `protobuf:"bytes,3,rep,name=log_entries,json=logEntries" json:"log_entries,omitempty"`
	Final      bool     `protobuf:"varint,4,opt,name=final" json:"final"`
}

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

var xxx_messageInfo_SnapshotRequest proto.InternalMessageInfo

type SnapshotRequest_Header struct {
	// The replica state at the time the snapshot was generated. Note
	// that ReplicaState.Desc differs from the above range_descriptor
	// field which holds the updated descriptor after the new replica
	// has been added while ReplicaState.Desc holds the descriptor
	// before the new replica has been added.
	State kvserverpb.ReplicaState `protobuf:"bytes,5,opt,name=state" json:"state"`
	// The inner raft message is of type MsgSnap, and its snapshot data contains a UUID.
	RaftMessageRequest RaftMessageRequest `protobuf:"bytes,2,opt,name=raft_message_request,json=raftMessageRequest" json:"raft_message_request"`
	// The estimated size of the range, to be used in reservation decisions.
	RangeSize int64 `protobuf:"varint,3,opt,name=range_size,json=rangeSize" json:"range_size"`
	// can_decline is set on preemptive snapshots, but not those generated
	// by raft because at that point it is better to queue up the stream
	// than to cancel it.
	CanDecline bool `protobuf:"varint,4,opt,name=can_decline,json=canDecline" json:"can_decline"`
	// The priority of the snapshot.
	Priority SnapshotRequest_Priority `protobuf:"varint,6,opt,name=priority,enum=cockroach.kv.kvserver.SnapshotRequest_Priority" json:"priority"`
	// The strategy of the snapshot.
	Strategy SnapshotRequest_Strategy `protobuf:"varint,7,opt,name=strategy,enum=cockroach.kv.kvserver.SnapshotRequest_Strategy" json:"strategy"`
	// The type of the snapshot.
	Type SnapshotRequest_Type `protobuf:"varint,9,opt,name=type,enum=cockroach.kv.kvserver.SnapshotRequest_Type" json:"type"`
	// Whether the snapshot uses the unreplicated RaftTruncatedState or not.
	// This is generally always true at 2.2 and above outside of the migration
	// phase, though theoretically it could take a long time for all ranges
	// to update to the new mechanism. This bool is true iff the Raft log at
	// the snapshot's applied index is using the new key. In particular, it
	// is true if the index itself carries out the migration (in which case
	// the data in the snapshot contains neither key).
	//
	// See VersionUnreplicatedRaftTruncatedState.
	UnreplicatedTruncatedState bool `protobuf:"varint,8,opt,name=unreplicated_truncated_state,json=unreplicatedTruncatedState" json:"unreplicated_truncated_state"`
}

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

var xxx_messageInfo_SnapshotRequest_Header proto.InternalMessageInfo

type SnapshotResponse struct {
	Status  SnapshotResponse_Status `protobuf:"varint,1,opt,name=status,enum=cockroach.kv.kvserver.SnapshotResponse_Status" json:"status"`
	Message string                  `protobuf:"bytes,2,opt,name=message" json:"message"`
}

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

var xxx_messageInfo_SnapshotResponse proto.InternalMessageInfo

// ConfChangeContext is encoded in the raftpb.ConfChange.Context field.
type ConfChangeContext struct {
	CommandID string `protobuf:"bytes,1,opt,name=command_id,json=commandId" json:"command_id"`
	// Payload is the application-level command (i.e. an encoded
	// kvserverpb.RaftCommand).
	Payload []byte `protobuf:"bytes,2,opt,name=payload" json:"payload,omitempty"`
}

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

var xxx_messageInfo_ConfChangeContext proto.InternalMessageInfo

func init() {
	proto.RegisterType((*RaftHeartbeat)(nil), "cockroach.kv.kvserver.RaftHeartbeat")
	proto.RegisterType((*RaftMessageRequest)(nil), "cockroach.kv.kvserver.RaftMessageRequest")
	proto.RegisterType((*RaftMessageRequestBatch)(nil), "cockroach.kv.kvserver.RaftMessageRequestBatch")
	proto.RegisterType((*RaftMessageResponseUnion)(nil), "cockroach.kv.kvserver.RaftMessageResponseUnion")
	proto.RegisterType((*RaftMessageResponse)(nil), "cockroach.kv.kvserver.RaftMessageResponse")
	proto.RegisterType((*SnapshotRequest)(nil), "cockroach.kv.kvserver.SnapshotRequest")
	proto.RegisterType((*SnapshotRequest_Header)(nil), "cockroach.kv.kvserver.SnapshotRequest.Header")
	proto.RegisterType((*SnapshotResponse)(nil), "cockroach.kv.kvserver.SnapshotResponse")
	proto.RegisterType((*ConfChangeContext)(nil), "cockroach.kv.kvserver.ConfChangeContext")
	proto.RegisterEnum("cockroach.kv.kvserver.SnapshotRequest_Priority", SnapshotRequest_Priority_name, SnapshotRequest_Priority_value)
	proto.RegisterEnum("cockroach.kv.kvserver.SnapshotRequest_Strategy", SnapshotRequest_Strategy_name, SnapshotRequest_Strategy_value)
	proto.RegisterEnum("cockroach.kv.kvserver.SnapshotRequest_Type", SnapshotRequest_Type_name, SnapshotRequest_Type_value)
	proto.RegisterEnum("cockroach.kv.kvserver.SnapshotResponse_Status", SnapshotResponse_Status_name, SnapshotResponse_Status_value)
}
func (m *RaftHeartbeat) 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 *RaftHeartbeat) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.RangeID))
	dAtA[i] = 0x10
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.FromReplicaID))
	dAtA[i] = 0x18
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.ToReplicaID))
	dAtA[i] = 0x20
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.Term))
	dAtA[i] = 0x28
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.Commit))
	dAtA[i] = 0x30
	i++
	if m.Quiesce {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x38
	i++
	if m.ToIsLearner {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	return i, nil
}

func (m *RaftMessageRequest) 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 *RaftMessageRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.RangeID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.FromReplica.Size()))
	n1, err := m.FromReplica.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	dAtA[i] = 0x1a
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.ToReplica.Size()))
	n2, err := m.ToReplica.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	dAtA[i] = 0x22
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.Message.Size()))
	n3, err := m.Message.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n3
	dAtA[i] = 0x28
	i++
	if m.Quiesce {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	if len(m.Heartbeats) > 0 {
		for _, msg := range m.Heartbeats {
			dAtA[i] = 0x32
			i++
			i = encodeVarintRaft(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.HeartbeatResps) > 0 {
		for _, msg := range m.HeartbeatResps {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintRaft(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.RangeStartKey != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.RangeStartKey)))
		i += copy(dAtA[i:], m.RangeStartKey)
	}
	return i, nil
}

func (m *RaftMessageRequestBatch) 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 *RaftMessageRequestBatch) 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 = encodeVarintRaft(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *RaftMessageResponseUnion) 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 *RaftMessageResponseUnion) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Error != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Error.Size()))
		n4, err := m.Error.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	return i, nil
}

func (m *RaftMessageResponse) 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 *RaftMessageResponse) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x8
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.RangeID))
	dAtA[i] = 0x12
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.FromReplica.Size()))
	n5, err := m.FromReplica.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	dAtA[i] = 0x1a
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.ToReplica.Size()))
	n6, err := m.ToReplica.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	dAtA[i] = 0x22
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.Union.Size()))
	n7, err := m.Union.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n7
	return i, nil
}

func (m *SnapshotRequest) 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 *SnapshotRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRaft(dAtA, i, uint64(m.Header.Size()))
		n8, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.KVBatch != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRaft(dAtA, i, uint64(len(m.KVBatch)))
		i += copy(dAtA[i:], m.KVBatch)
	}
	if len(m.LogEntries) > 0 {
		for _, b := range m.LogEntries {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintRaft(dAtA, i, uint64(len(b)))
			i += copy(dAtA[i:], b)
		}
	}
	dAtA[i] = 0x20
	i++
	if m.Final {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	return i, nil
}

func (m *SnapshotRequest_Header) 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 *SnapshotRequest_Header) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x12
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.RaftMessageRequest.Size()))
	n9, err := m.RaftMessageRequest.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n9
	dAtA[i] = 0x18
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.RangeSize))
	dAtA[i] = 0x20
	i++
	if m.CanDecline {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x2a
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.State.Size()))
	n10, err := m.State.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n10
	dAtA[i] = 0x30
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.Priority))
	dAtA[i] = 0x38
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.Strategy))
	dAtA[i] = 0x40
	i++
	if m.UnreplicatedTruncatedState {
		dAtA[i] = 1
	} else {
		dAtA[i] = 0
	}
	i++
	dAtA[i] = 0x48
	i++
	i = encodeVarintRaft(dAtA, i, uint64(m.Type))
	return i, nil
}

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

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

func encodeVarintRaft(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 *RaftHeartbeat) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaft(uint64(m.RangeID))
	n += 1 + sovRaft(uint64(m.FromReplicaID))
	n += 1 + sovRaft(uint64(m.ToReplicaID))
	n += 1 + sovRaft(uint64(m.Term))
	n += 1 + sovRaft(uint64(m.Commit))
	n += 2
	n += 2
	return n
}

func (m *RaftMessageRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaft(uint64(m.RangeID))
	l = m.FromReplica.Size()
	n += 1 + l + sovRaft(uint64(l))
	l = m.ToReplica.Size()
	n += 1 + l + sovRaft(uint64(l))
	l = m.Message.Size()
	n += 1 + l + sovRaft(uint64(l))
	n += 2
	if len(m.Heartbeats) > 0 {
		for _, e := range m.Heartbeats {
			l = e.Size()
			n += 1 + l + sovRaft(uint64(l))
		}
	}
	if len(m.HeartbeatResps) > 0 {
		for _, e := range m.HeartbeatResps {
			l = e.Size()
			n += 1 + l + sovRaft(uint64(l))
		}
	}
	if m.RangeStartKey != nil {
		l = len(m.RangeStartKey)
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}

func (m *RaftMessageRequestBatch) 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 + sovRaft(uint64(l))
		}
	}
	return n
}

func (m *RaftMessageResponseUnion) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Error != nil {
		l = m.Error.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}

func (m *RaftMessageResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaft(uint64(m.RangeID))
	l = m.FromReplica.Size()
	n += 1 + l + sovRaft(uint64(l))
	l = m.ToReplica.Size()
	n += 1 + l + sovRaft(uint64(l))
	l = m.Union.Size()
	n += 1 + l + sovRaft(uint64(l))
	return n
}

func (m *SnapshotRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovRaft(uint64(l))
	}
	if m.KVBatch != nil {
		l = len(m.KVBatch)
		n += 1 + l + sovRaft(uint64(l))
	}
	if len(m.LogEntries) > 0 {
		for _, b := range m.LogEntries {
			l = len(b)
			n += 1 + l + sovRaft(uint64(l))
		}
	}
	n += 2
	return n
}

func (m *SnapshotRequest_Header) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.RaftMessageRequest.Size()
	n += 1 + l + sovRaft(uint64(l))
	n += 1 + sovRaft(uint64(m.RangeSize))
	n += 2
	l = m.State.Size()
	n += 1 + l + sovRaft(uint64(l))
	n += 1 + sovRaft(uint64(m.Priority))
	n += 1 + sovRaft(uint64(m.Strategy))
	n += 2
	n += 1 + sovRaft(uint64(m.Type))
	return n
}

func (m *SnapshotResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 1 + sovRaft(uint64(m.Status))
	l = len(m.Message)
	n += 1 + l + sovRaft(uint64(l))
	return n
}

func (m *ConfChangeContext) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.CommandID)
	n += 1 + l + sovRaft(uint64(l))
	if m.Payload != nil {
		l = len(m.Payload)
		n += 1 + l + sovRaft(uint64(l))
	}
	return n
}

func sovRaft(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozRaft(x uint64) (n int) {
	return sovRaft(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *RaftMessageResponseUnion) GetValue() interface{} {
	if this.Error != nil {
		return this.Error
	}
	return nil
}

func (this *RaftMessageResponseUnion) SetValue(value interface{}) bool {
	switch vt := value.(type) {
	case *roachpb.Error:
		this.Error = vt
	default:
		return false
	}
	return true
}
func (m *RaftHeartbeat) 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 ErrIntOverflowRaft
			}
			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: RaftHeartbeat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftHeartbeat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeID", wireType)
			}
			m.RangeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RangeID |= (github_com_cockroachdb_cockroach_pkg_roachpb.RangeID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromReplicaID", wireType)
			}
			m.FromReplicaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FromReplicaID |= (github_com_cockroachdb_cockroach_pkg_roachpb.ReplicaID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToReplicaID", wireType)
			}
			m.ToReplicaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ToReplicaID |= (github_com_cockroachdb_cockroach_pkg_roachpb.ReplicaID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
			}
			m.Term = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Term |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
			}
			m.Commit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Commit |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quiesce", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Quiesce = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToIsLearner", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ToIsLearner = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RaftMessageRequest) 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 ErrIntOverflowRaft
			}
			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: RaftMessageRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeID", wireType)
			}
			m.RangeID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RangeID |= (github_com_cockroachdb_cockroach_pkg_roachpb.RangeID(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromReplica", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.FromReplica.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToReplica", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ToReplica.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quiesce", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Quiesce = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heartbeats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Heartbeats = append(m.Heartbeats, RaftHeartbeat{})
			if err := m.Heartbeats[len(m.Heartbeats)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field HeartbeatResps", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.HeartbeatResps = append(m.HeartbeatResps, RaftHeartbeat{})
			if err := m.HeartbeatResps[len(m.HeartbeatResps)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeStartKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RangeStartKey = append(m.RangeStartKey[:0], dAtA[iNdEx:postIndex]...)
			if m.RangeStartKey == nil {
				m.RangeStartKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RaftMessageRequestBatch) 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 ErrIntOverflowRaft
			}
			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: RaftMessageRequestBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftMessageRequestBatch: 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 ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Requests = append(m.Requests, RaftMessageRequest{})
			if err := m.Requests[len(m.Requests)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SnapshotRequest) 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 ErrIntOverflowRaft
			}
			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: SnapshotRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &SnapshotRequest_Header{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KVBatch", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KVBatch = append(m.KVBatch[:0], dAtA[iNdEx:postIndex]...)
			if m.KVBatch == nil {
				m.KVBatch = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogEntries", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LogEntries = append(m.LogEntries, make([]byte, postIndex-iNdEx))
			copy(m.LogEntries[len(m.LogEntries)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Final", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Final = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SnapshotRequest_Header) 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 ErrIntOverflowRaft
			}
			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: Header: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaftMessageRequest", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RaftMessageRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RangeSize", wireType)
			}
			m.RangeSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RangeSize |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CanDecline", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.CanDecline = bool(v != 0)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRaft
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
			}
			m.Priority = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Priority |= (SnapshotRequest_Priority(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Strategy", wireType)
			}
			m.Strategy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Strategy |= (SnapshotRequest_Strategy(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnreplicatedTruncatedState", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.UnreplicatedTruncatedState = bool(v != 0)
		case 9:
			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 ErrIntOverflowRaft
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= (SnapshotRequest_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRaft(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRaft
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

func init() { proto.RegisterFile("kv/kvserver/raft.proto", fileDescriptor_raft_3fc2b336b3beae43) }

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