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

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

package kvserverpb

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"
import enginepb "github.com/cockroachdb/cockroach/pkg/storage/enginepb"
import hlc "github.com/cockroachdb/cockroach/pkg/util/hlc"

import github_com_cockroachdb_cockroach_pkg_util_uuid "github.com/cockroachdb/cockroach/pkg/util/uuid"
import github_com_cockroachdb_cockroach_pkg_roachpb "github.com/cockroachdb/cockroach/pkg/roachpb"

import bytes "bytes"

import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"

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

// Split is emitted when a Replica commits a split trigger. It signals that the
// Replica has prepared the on-disk state for both the left and right hand
// sides of the split, and that the left hand side Replica should be updated as
// well as the right hand side created.
type Split struct {
	roachpb.SplitTrigger `protobuf:"bytes,1,opt,name=trigger,proto3,embedded=trigger" json:"trigger"`
	// RHSDelta holds the statistics for what was written to what is now the
	// right-hand side of the split during the batch which executed it.
	// The on-disk state of the right-hand side is already correct, but the
	// Store must learn about this delta to update its counters appropriately.
	RHSDelta enginepb.MVCCStats `protobuf:"bytes,2,opt,name=rhs_delta,json=rhsDelta,proto3" json:"rhs_delta"`
}

func (m *Split) Reset()         { *m = Split{} }
func (m *Split) String() string { return proto.CompactTextString(m) }
func (*Split) ProtoMessage()    {}
func (*Split) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{0}
}
func (m *Split) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Split) 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 *Split) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Split.Merge(dst, src)
}
func (m *Split) XXX_Size() int {
	return m.Size()
}
func (m *Split) XXX_DiscardUnknown() {
	xxx_messageInfo_Split.DiscardUnknown(m)
}

var xxx_messageInfo_Split proto.InternalMessageInfo

// Merge is emitted by a Replica which commits a transaction with
// a MergeTrigger (i.e. absorbs its right neighbor).
type Merge struct {
	roachpb.MergeTrigger `protobuf:"bytes,1,opt,name=trigger,proto3,embedded=trigger" json:"trigger"`
}

func (m *Merge) Reset()         { *m = Merge{} }
func (m *Merge) String() string { return proto.CompactTextString(m) }
func (*Merge) ProtoMessage()    {}
func (*Merge) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{1}
}
func (m *Merge) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Merge) 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 *Merge) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Merge.Merge(dst, src)
}
func (m *Merge) XXX_Size() int {
	return m.Size()
}
func (m *Merge) XXX_DiscardUnknown() {
	xxx_messageInfo_Merge.DiscardUnknown(m)
}

var xxx_messageInfo_Merge proto.InternalMessageInfo

// ChangeReplicas is emitted by a Replica which commits a transaction with
// a ChangeReplicasTrigger.
type ChangeReplicas struct {
	roachpb.ChangeReplicasTrigger `protobuf:"bytes,1,opt,name=trigger,proto3,embedded=trigger" json:"trigger"`
}

func (m *ChangeReplicas) Reset()      { *m = ChangeReplicas{} }
func (*ChangeReplicas) ProtoMessage() {}
func (*ChangeReplicas) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{2}
}
func (m *ChangeReplicas) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ChangeReplicas) 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 *ChangeReplicas) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ChangeReplicas.Merge(dst, src)
}
func (m *ChangeReplicas) XXX_Size() int {
	return m.Size()
}
func (m *ChangeReplicas) XXX_DiscardUnknown() {
	xxx_messageInfo_ChangeReplicas.DiscardUnknown(m)
}

var xxx_messageInfo_ChangeReplicas proto.InternalMessageInfo

// ComputeChecksum is emitted when a ComputeChecksum request is evaluated. It
// instructs the replica to compute a checksum at the time the command is
// applied.
type ComputeChecksum struct {
	// ChecksumID is a handle by which the checksum can be retrieved in a later
	// CollectChecksum request.
	ChecksumID github_com_cockroachdb_cockroach_pkg_util_uuid.UUID `protobuf:"bytes,1,opt,name=checksum_id,json=checksumId,proto3,customtype=github.com/cockroachdb/cockroach/pkg/util/uuid.UUID" json:"checksum_id"`
	// The version used to pick the checksum method. Only when the version matches
	// that hardcoded in the binary will a computation be carried out.
	Version uint32 `protobuf:"varint,5,opt,name=version,proto3" json:"version,omitempty"`
	// SaveSnapshot indicates that the snapshot used to compute the checksum
	// should be saved so that a diff of divergent replicas can later be computed.
	SaveSnapshot bool                 `protobuf:"varint,2,opt,name=save_snapshot,json=saveSnapshot,proto3" json:"save_snapshot,omitempty"`
	Mode         roachpb.ChecksumMode `protobuf:"varint,3,opt,name=mode,proto3,enum=cockroach.roachpb.ChecksumMode" json:"mode,omitempty"`
	// If set, a checkpoint (i.e. cheap backup) of the engine will be taken. This
	// is expected to be set only if we already know that there is an
	// inconsistency and we want to preserve as much state as possible.
	Checkpoint bool `protobuf:"varint,4,opt,name=checkpoint,proto3" json:"checkpoint,omitempty"`
	// Replicas processing this command which find themselves in this slice will
	// terminate. See `CheckConsistencyRequest.Terminate`.
	Terminate []roachpb.ReplicaDescriptor `protobuf:"bytes,6,rep,name=terminate,proto3" json:"terminate"`
}

func (m *ComputeChecksum) Reset()         { *m = ComputeChecksum{} }
func (m *ComputeChecksum) String() string { return proto.CompactTextString(m) }
func (*ComputeChecksum) ProtoMessage()    {}
func (*ComputeChecksum) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{3}
}
func (m *ComputeChecksum) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ComputeChecksum) 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 *ComputeChecksum) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComputeChecksum.Merge(dst, src)
}
func (m *ComputeChecksum) XXX_Size() int {
	return m.Size()
}
func (m *ComputeChecksum) XXX_DiscardUnknown() {
	xxx_messageInfo_ComputeChecksum.DiscardUnknown(m)
}

var xxx_messageInfo_ComputeChecksum proto.InternalMessageInfo

// Compaction holds core details about a suggested compaction.
type Compaction struct {
	// bytes indicates the expected space reclamation from compaction.
	Bytes int64 `protobuf:"varint,1,opt,name=bytes,proto3" json:"bytes,omitempty"`
	// suggested_at is nanoseconds since the epoch.
	SuggestedAtNanos int64 `protobuf:"varint,2,opt,name=suggested_at_nanos,json=suggestedAtNanos,proto3" json:"suggested_at_nanos,omitempty"`
}

func (m *Compaction) Reset()         { *m = Compaction{} }
func (m *Compaction) String() string { return proto.CompactTextString(m) }
func (*Compaction) ProtoMessage()    {}
func (*Compaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{4}
}
func (m *Compaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Compaction) 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 *Compaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Compaction.Merge(dst, src)
}
func (m *Compaction) XXX_Size() int {
	return m.Size()
}
func (m *Compaction) XXX_DiscardUnknown() {
	xxx_messageInfo_Compaction.DiscardUnknown(m)
}

var xxx_messageInfo_Compaction proto.InternalMessageInfo

// SuggestedCompaction holds start and end keys in conjunction with
// the compaction details.
type SuggestedCompaction struct {
	StartKey   github_com_cockroachdb_cockroach_pkg_roachpb.Key `protobuf:"bytes,1,opt,name=start_key,json=startKey,proto3,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.Key" json:"start_key,omitempty"`
	EndKey     github_com_cockroachdb_cockroach_pkg_roachpb.Key `protobuf:"bytes,2,opt,name=end_key,json=endKey,proto3,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.Key" json:"end_key,omitempty"`
	Compaction `protobuf:"bytes,3,opt,name=compaction,proto3,embedded=compaction" json:"compaction"`
}

func (m *SuggestedCompaction) Reset()         { *m = SuggestedCompaction{} }
func (m *SuggestedCompaction) String() string { return proto.CompactTextString(m) }
func (*SuggestedCompaction) ProtoMessage()    {}
func (*SuggestedCompaction) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{5}
}
func (m *SuggestedCompaction) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SuggestedCompaction) 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 *SuggestedCompaction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SuggestedCompaction.Merge(dst, src)
}
func (m *SuggestedCompaction) XXX_Size() int {
	return m.Size()
}
func (m *SuggestedCompaction) XXX_DiscardUnknown() {
	xxx_messageInfo_SuggestedCompaction.DiscardUnknown(m)
}

var xxx_messageInfo_SuggestedCompaction proto.InternalMessageInfo

// ReplicatedEvalResult is the structured information which together with
// a RocksDB WriteBatch constitutes the proposal payload in proposer-evaluated
// KV. For the majority of proposals, we expect ReplicatedEvalResult to be
// trivial; only changes to the metadata state (splits, merges, rebalances,
// leases, log truncation, ...) of the Replica or certain special commands must
// sideline information here based on which all Replicas must take action.
type ReplicatedEvalResult struct {
	// Updates to the Replica's ReplicaState. By convention and as outlined on
	// the comment on the ReplicaState message, this field is sparsely populated
	// and any field set overwrites the corresponding field in the state, perhaps
	// with additional side effects (for instance on a descriptor update).
	State           *ReplicaState    `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
	Split           *Split           `protobuf:"bytes,3,opt,name=split,proto3" json:"split,omitempty"`
	Merge           *Merge           `protobuf:"bytes,4,opt,name=merge,proto3" json:"merge,omitempty"`
	ComputeChecksum *ComputeChecksum `protobuf:"bytes,21,opt,name=compute_checksum,json=computeChecksum,proto3" json:"compute_checksum,omitempty"`
	IsLeaseRequest  bool             `protobuf:"varint,6,opt,name=is_lease_request,json=isLeaseRequest,proto3" json:"is_lease_request,omitempty"`
	// Duplicates BatchRequest.Timestamp for proposer-evaluated KV. Used
	// to verify the validity of the command (for lease coverage and GC
	// threshold).
	Timestamp hlc.Timestamp `protobuf:"bytes,8,opt,name=timestamp,proto3" json:"timestamp"`
	// The stats delta corresponding to the data in this WriteBatch. On
	// a split, contains only the contributions to the left-hand side.
	DeprecatedDelta *enginepb.MVCCStats              `protobuf:"bytes,10,opt,name=deprecated_delta,json=deprecatedDelta,proto3" json:"deprecated_delta,omitempty"`
	Delta           enginepb.MVCCStatsDelta          `protobuf:"bytes,18,opt,name=delta,proto3" json:"delta"`
	ChangeReplicas  *ChangeReplicas                  `protobuf:"bytes,12,opt,name=change_replicas,json=changeReplicas,proto3" json:"change_replicas,omitempty"`
	RaftLogDelta    int64                            `protobuf:"varint,13,opt,name=raft_log_delta,json=raftLogDelta,proto3" json:"raft_log_delta,omitempty"`
	AddSSTable      *ReplicatedEvalResult_AddSSTable `protobuf:"bytes,17,opt,name=add_sstable,json=addSstable,proto3" json:"add_sstable,omitempty"`
	// suggested_compactions are sent to the engine's compactor to
	// reclaim storage space after garbage collection or cleared /
	// rebalanced ranges.
	SuggestedCompactions []SuggestedCompaction `protobuf:"bytes,19,rep,name=suggested_compactions,json=suggestedCompactions,proto3" json:"suggested_compactions"`
	// This is the proposal timestamp for the active lease while evaluating a lease request.
	// It will be used to make sure we know if a lease was extended after we sent out the request
	// but before we tried to apply it.
	PrevLeaseProposal *hlc.Timestamp `protobuf:"bytes,20,opt,name=prev_lease_proposal,json=prevLeaseProposal,proto3" json:"prev_lease_proposal,omitempty"`
}

func (m *ReplicatedEvalResult) Reset()         { *m = ReplicatedEvalResult{} }
func (m *ReplicatedEvalResult) String() string { return proto.CompactTextString(m) }
func (*ReplicatedEvalResult) ProtoMessage()    {}
func (*ReplicatedEvalResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{6}
}
func (m *ReplicatedEvalResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicatedEvalResult) 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 *ReplicatedEvalResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicatedEvalResult.Merge(dst, src)
}
func (m *ReplicatedEvalResult) XXX_Size() int {
	return m.Size()
}
func (m *ReplicatedEvalResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicatedEvalResult.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicatedEvalResult proto.InternalMessageInfo

// AddSSTable is a side effect that must execute before the Raft application
// is committed. It must be idempotent to account for an ill-timed crash after
// applying the side effect, but before committing the batch.
//
// TODO(tschottdorf): additionally, after the crash, the node must not serve
// traffic until the persisted committed log has fully applied. Otherwise, we
// risk exposing data created through such a side effect whose corresponding
// Raft command hasn't committed yet. This isn't so much an issue with AddSSTable
// since these Ranges are not user-visible, but it is a general concern assuming
// other such side effects are added.
type ReplicatedEvalResult_AddSSTable struct {
	Data  []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	CRC32 uint32 `protobuf:"varint,2,opt,name=crc32,proto3" json:"crc32,omitempty"`
}

func (m *ReplicatedEvalResult_AddSSTable) Reset()         { *m = ReplicatedEvalResult_AddSSTable{} }
func (m *ReplicatedEvalResult_AddSSTable) String() string { return proto.CompactTextString(m) }
func (*ReplicatedEvalResult_AddSSTable) ProtoMessage()    {}
func (*ReplicatedEvalResult_AddSSTable) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{6, 0}
}
func (m *ReplicatedEvalResult_AddSSTable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReplicatedEvalResult_AddSSTable) 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 *ReplicatedEvalResult_AddSSTable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReplicatedEvalResult_AddSSTable.Merge(dst, src)
}
func (m *ReplicatedEvalResult_AddSSTable) XXX_Size() int {
	return m.Size()
}
func (m *ReplicatedEvalResult_AddSSTable) XXX_DiscardUnknown() {
	xxx_messageInfo_ReplicatedEvalResult_AddSSTable.DiscardUnknown(m)
}

var xxx_messageInfo_ReplicatedEvalResult_AddSSTable proto.InternalMessageInfo

// WriteBatch is the serialized representation of a RocksDB write
// batch. A wrapper message is used so that the absence of the field
// can be distinguished from a zero-length batch, and so structs
// containing pointers to it can be compared with the == operator.
type WriteBatch struct {
	Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *WriteBatch) Reset()         { *m = WriteBatch{} }
func (m *WriteBatch) String() string { return proto.CompactTextString(m) }
func (*WriteBatch) ProtoMessage()    {}
func (*WriteBatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{7}
}
func (m *WriteBatch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *WriteBatch) 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 *WriteBatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WriteBatch.Merge(dst, src)
}
func (m *WriteBatch) XXX_Size() int {
	return m.Size()
}
func (m *WriteBatch) XXX_DiscardUnknown() {
	xxx_messageInfo_WriteBatch.DiscardUnknown(m)
}

var xxx_messageInfo_WriteBatch proto.InternalMessageInfo

// LogicalOpLog is a log of logical MVCC operations. A wrapper message
// is used so that the absence of the field can be distinguished from a
// zero-length batch, and so structs containing pointers to it can be
// compared with the == operator.
type LogicalOpLog struct {
	Ops []enginepb.MVCCLogicalOp `protobuf:"bytes,1,rep,name=ops,proto3" json:"ops"`
}

func (m *LogicalOpLog) Reset()         { *m = LogicalOpLog{} }
func (m *LogicalOpLog) String() string { return proto.CompactTextString(m) }
func (*LogicalOpLog) ProtoMessage()    {}
func (*LogicalOpLog) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{8}
}
func (m *LogicalOpLog) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogicalOpLog) 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 *LogicalOpLog) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogicalOpLog.Merge(dst, src)
}
func (m *LogicalOpLog) XXX_Size() int {
	return m.Size()
}
func (m *LogicalOpLog) XXX_DiscardUnknown() {
	xxx_messageInfo_LogicalOpLog.DiscardUnknown(m)
}

var xxx_messageInfo_LogicalOpLog proto.InternalMessageInfo

// RaftCommand is the message written to the raft log. It contains
// some metadata about the proposal itself, then either a BatchRequest
// (legacy mode) or a ReplicatedEvalResult + WriteBatch
// (proposer-evaluated KV mode).
type RaftCommand struct {
	// proposer_lease_seq is provided to verify at raft command apply-time
	// that the lease under which the command was proposed remains in effect.
	//
	// To see why lease verification downstream of Raft is required, consider the
	// following example:
	// - replica 1 receives a client request for a write
	// - replica 1 checks the lease; the write is permitted
	// - replica 1 proposes the command
	// - time passes, replica 2 commits a new lease
	// - the command applies on replica 1
	// - replica 2 serves anomalous reads which don't see the write
	// - the command applies on replica 2
	ProposerLeaseSequence github_com_cockroachdb_cockroach_pkg_roachpb.LeaseSequence `protobuf:"varint,6,opt,name=proposer_lease_sequence,json=proposerLeaseSequence,proto3,casttype=github.com/cockroachdb/cockroach/pkg/roachpb.LeaseSequence" json:"proposer_lease_sequence,omitempty"`
	// deprecated_proposer_lease served the same purpose as proposer_lease_seq.
	// As of VersionLeaseSequence, it is no longer in use.
	//
	// However, unless we add a check that all existing Raft logs on all nodes
	// in the cluster contain only "new" leases, we won't be able to remove the
	// legacy code.
	DeprecatedProposerLease *roachpb.Lease `protobuf:"bytes,5,opt,name=deprecated_proposer_lease,json=deprecatedProposerLease,proto3" json:"deprecated_proposer_lease,omitempty"`
	// When the command is applied, its result is an error if the lease log
	// counter has already reached (or exceeded) max_lease_index.
	//
	// The lease index is a reorder protection mechanism - we don't want Raft
	// commands (proposed by a single node, the one with proposer_lease) executing
	// in a different order than the one in which the corresponding KV requests
	// were evaluated and the commands were proposed. This is important because
	// latching does not fully serialize commands - mostly when it comes to
	// updates to the internal state of the range (this should be re-evaluated
	// once proposer-evaluated KV is completed - see #10413).
	// Similar to the Raft applied index, it is strictly increasing, but may have
	// gaps. A command will only apply successfully if its max_lease_index has not
	// been surpassed by the Range's applied lease index (in which case the
	// command may need to be retried, that is, regenerated with a higher
	// max_lease_index). When the command applies, the new lease index will
	// increase to max_lease_index (so a potential later replay will fail).
	//
	// This mechanism was introduced as a simpler alternative to using the Raft
	// applied index, which is fraught with complexity due to the need to predict
	// exactly the log position at which a command will apply, even when the Raft
	// leader is not colocated with the lease holder (which usually proposes all
	// commands).
	//
	// Pinning the lease-index to the assigned slot (as opposed to allowing gaps
	// as we do now) is an interesting venue to explore from the standpoint of
	// parallelization: One could hope to enforce command ordering in that way
	// (without recourse to a higher-level locking primitive such as the command
	// queue). This is a hard problem: First of all, managing the pending
	// commands gets more involved; a command must not be removed if others have
	// been added after it, and on removal, the assignment counters must be
	// updated accordingly. Managing retry of proposals becomes trickier as
	// well as that uproots whatever ordering was originally envisioned.
	MaxLeaseIndex uint64 `protobuf:"varint,4,opt,name=max_lease_index,json=maxLeaseIndex,proto3" json:"max_lease_index,omitempty"`
	// replicated_eval_result is a set of structured information that instructs
	// replicated state changes to the part of a Range's replicated state machine
	// that exists outside of RocksDB.
	ReplicatedEvalResult ReplicatedEvalResult `protobuf:"bytes,13,opt,name=replicated_eval_result,json=replicatedEvalResult,proto3" json:"replicated_eval_result"`
	// write_batch is a RocksDB WriteBatch that will be applied to RockDB during
	// the application of the Raft command. The batch can be thought of as a
	// series of replicated instructions that inform a RocksDB engine on how to
	// change.
	WriteBatch *WriteBatch `protobuf:"bytes,14,opt,name=write_batch,json=writeBatch,proto3" json:"write_batch,omitempty"`
	// logical_op_log contains a series of logical MVCC operations that correspond
	// to the physical operations being made in the write_batch.
	LogicalOpLog *LogicalOpLog `protobuf:"bytes,15,opt,name=logical_op_log,json=logicalOpLog,proto3" json:"logical_op_log,omitempty"`
	// trace_data, if not empty, contains details of proposer's trace as returned by
	// Tracer.Inject(opentracing.TextMap). Used to create span for command
	// application on all the replicas that "follow from" the proposer.
	TraceData map[string]string `protobuf:"bytes,16,rep,name=trace_data,json=traceData,proto3" json:"trace_data,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *RaftCommand) Reset()         { *m = RaftCommand{} }
func (m *RaftCommand) String() string { return proto.CompactTextString(m) }
func (*RaftCommand) ProtoMessage()    {}
func (*RaftCommand) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{9}
}
func (m *RaftCommand) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RaftCommand) 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 *RaftCommand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RaftCommand.Merge(dst, src)
}
func (m *RaftCommand) XXX_Size() int {
	return m.Size()
}
func (m *RaftCommand) XXX_DiscardUnknown() {
	xxx_messageInfo_RaftCommand.DiscardUnknown(m)
}

var xxx_messageInfo_RaftCommand proto.InternalMessageInfo

// RaftCommandFooter contains a subset of the fields in RaftCommand. It is used
// to optimize a pattern where most of the fields in RaftCommand are marshaled
// outside of a heavily contended critical section, except for the fields in the
// footer, which are assigned and marhsaled inside of the critical section and
// appended to the marshaled byte buffer. This minimizes the memory allocation
// and marshaling work performed under lock.
type RaftCommandFooter struct {
	MaxLeaseIndex uint64 `protobuf:"varint,4,opt,name=max_lease_index,json=maxLeaseIndex,proto3" json:"max_lease_index,omitempty"`
}

func (m *RaftCommandFooter) Reset()         { *m = RaftCommandFooter{} }
func (m *RaftCommandFooter) String() string { return proto.CompactTextString(m) }
func (*RaftCommandFooter) ProtoMessage()    {}
func (*RaftCommandFooter) Descriptor() ([]byte, []int) {
	return fileDescriptor_proposer_kv_baa0b8d6d33a3e71, []int{10}
}
func (m *RaftCommandFooter) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RaftCommandFooter) 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 *RaftCommandFooter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RaftCommandFooter.Merge(dst, src)
}
func (m *RaftCommandFooter) XXX_Size() int {
	return m.Size()
}
func (m *RaftCommandFooter) XXX_DiscardUnknown() {
	xxx_messageInfo_RaftCommandFooter.DiscardUnknown(m)
}

var xxx_messageInfo_RaftCommandFooter proto.InternalMessageInfo

func init() {
	proto.RegisterType((*Split)(nil), "cockroach.kv.kvserver.storagepb.Split")
	proto.RegisterType((*Merge)(nil), "cockroach.kv.kvserver.storagepb.Merge")
	proto.RegisterType((*ChangeReplicas)(nil), "cockroach.kv.kvserver.storagepb.ChangeReplicas")
	proto.RegisterType((*ComputeChecksum)(nil), "cockroach.kv.kvserver.storagepb.ComputeChecksum")
	proto.RegisterType((*Compaction)(nil), "cockroach.kv.kvserver.storagepb.Compaction")
	proto.RegisterType((*SuggestedCompaction)(nil), "cockroach.kv.kvserver.storagepb.SuggestedCompaction")
	proto.RegisterType((*ReplicatedEvalResult)(nil), "cockroach.kv.kvserver.storagepb.ReplicatedEvalResult")
	proto.RegisterType((*ReplicatedEvalResult_AddSSTable)(nil), "cockroach.kv.kvserver.storagepb.ReplicatedEvalResult.AddSSTable")
	proto.RegisterType((*WriteBatch)(nil), "cockroach.kv.kvserver.storagepb.WriteBatch")
	proto.RegisterType((*LogicalOpLog)(nil), "cockroach.kv.kvserver.storagepb.LogicalOpLog")
	proto.RegisterType((*RaftCommand)(nil), "cockroach.kv.kvserver.storagepb.RaftCommand")
	proto.RegisterMapType((map[string]string)(nil), "cockroach.kv.kvserver.storagepb.RaftCommand.TraceDataEntry")
	proto.RegisterType((*RaftCommandFooter)(nil), "cockroach.kv.kvserver.storagepb.RaftCommandFooter")
}
func (this *Split) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

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

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

	that1, ok := that.(*ComputeChecksum)
	if !ok {
		that2, ok := that.(ComputeChecksum)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ChecksumID.Equal(that1.ChecksumID) {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if this.SaveSnapshot != that1.SaveSnapshot {
		return false
	}
	if this.Mode != that1.Mode {
		return false
	}
	if this.Checkpoint != that1.Checkpoint {
		return false
	}
	if len(this.Terminate) != len(that1.Terminate) {
		return false
	}
	for i := range this.Terminate {
		if !this.Terminate[i].Equal(&that1.Terminate[i]) {
			return false
		}
	}
	return true
}
func (this *Compaction) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*SuggestedCompaction)
	if !ok {
		that2, ok := that.(SuggestedCompaction)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.StartKey, that1.StartKey) {
		return false
	}
	if !bytes.Equal(this.EndKey, that1.EndKey) {
		return false
	}
	if !this.Compaction.Equal(&that1.Compaction) {
		return false
	}
	return true
}
func (this *ReplicatedEvalResult) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicatedEvalResult)
	if !ok {
		that2, ok := that.(ReplicatedEvalResult)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.State.Equal(that1.State) {
		return false
	}
	if !this.Split.Equal(that1.Split) {
		return false
	}
	if !this.Merge.Equal(that1.Merge) {
		return false
	}
	if !this.ComputeChecksum.Equal(that1.ComputeChecksum) {
		return false
	}
	if this.IsLeaseRequest != that1.IsLeaseRequest {
		return false
	}
	if !this.Timestamp.Equal(&that1.Timestamp) {
		return false
	}
	if !this.DeprecatedDelta.Equal(that1.DeprecatedDelta) {
		return false
	}
	if !this.Delta.Equal(&that1.Delta) {
		return false
	}
	if !this.ChangeReplicas.Equal(that1.ChangeReplicas) {
		return false
	}
	if this.RaftLogDelta != that1.RaftLogDelta {
		return false
	}
	if !this.AddSSTable.Equal(that1.AddSSTable) {
		return false
	}
	if len(this.SuggestedCompactions) != len(that1.SuggestedCompactions) {
		return false
	}
	for i := range this.SuggestedCompactions {
		if !this.SuggestedCompactions[i].Equal(&that1.SuggestedCompactions[i]) {
			return false
		}
	}
	if !this.PrevLeaseProposal.Equal(that1.PrevLeaseProposal) {
		return false
	}
	return true
}
func (this *ReplicatedEvalResult_AddSSTable) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ReplicatedEvalResult_AddSSTable)
	if !ok {
		that2, ok := that.(ReplicatedEvalResult_AddSSTable)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	if this.CRC32 != that1.CRC32 {
		return false
	}
	return true
}
func (m *Split) 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 *Split) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintProposerKv(dAtA, i, uint64(m.SplitTrigger.Size()))
	n1, err := m.SplitTrigger.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n1
	dAtA[i] = 0x12
	i++
	i = encodeVarintProposerKv(dAtA, i, uint64(m.RHSDelta.Size()))
	n2, err := m.RHSDelta.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n2
	return i, nil
}

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

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

func (m *ComputeChecksum) 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 *ComputeChecksum) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintProposerKv(dAtA, i, uint64(m.ChecksumID.Size()))
	n5, err := m.ChecksumID.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n5
	if m.SaveSnapshot {
		dAtA[i] = 0x10
		i++
		if m.SaveSnapshot {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Mode != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.Mode))
	}
	if m.Checkpoint {
		dAtA[i] = 0x20
		i++
		if m.Checkpoint {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.Version != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.Version))
	}
	if len(m.Terminate) > 0 {
		for _, msg := range m.Terminate {
			dAtA[i] = 0x32
			i++
			i = encodeVarintProposerKv(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *SuggestedCompaction) 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 *SuggestedCompaction) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.StartKey) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(len(m.StartKey)))
		i += copy(dAtA[i:], m.StartKey)
	}
	if len(m.EndKey) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(len(m.EndKey)))
		i += copy(dAtA[i:], m.EndKey)
	}
	dAtA[i] = 0x1a
	i++
	i = encodeVarintProposerKv(dAtA, i, uint64(m.Compaction.Size()))
	n6, err := m.Compaction.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n6
	return i, nil
}

func (m *ReplicatedEvalResult) 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 *ReplicatedEvalResult) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.State != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.State.Size()))
		n7, err := m.State.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.Split != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.Split.Size()))
		n8, err := m.Split.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.Merge != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.Merge.Size()))
		n9, err := m.Merge.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.IsLeaseRequest {
		dAtA[i] = 0x30
		i++
		if m.IsLeaseRequest {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	dAtA[i] = 0x42
	i++
	i = encodeVarintProposerKv(dAtA, i, uint64(m.Timestamp.Size()))
	n10, err := m.Timestamp.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n10
	if m.DeprecatedDelta != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.DeprecatedDelta.Size()))
		n11, err := m.DeprecatedDelta.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	if m.ChangeReplicas != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.ChangeReplicas.Size()))
		n12, err := m.ChangeReplicas.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	if m.RaftLogDelta != 0 {
		dAtA[i] = 0x68
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.RaftLogDelta))
	}
	if m.AddSSTable != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.AddSSTable.Size()))
		n13, err := m.AddSSTable.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	dAtA[i] = 0x92
	i++
	dAtA[i] = 0x1
	i++
	i = encodeVarintProposerKv(dAtA, i, uint64(m.Delta.Size()))
	n14, err := m.Delta.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n14
	if len(m.SuggestedCompactions) > 0 {
		for _, msg := range m.SuggestedCompactions {
			dAtA[i] = 0x9a
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintProposerKv(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.PrevLeaseProposal != nil {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.PrevLeaseProposal.Size()))
		n15, err := m.PrevLeaseProposal.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	if m.ComputeChecksum != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.ComputeChecksum.Size()))
		n16, err := m.ComputeChecksum.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}

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

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

func (m *LogicalOpLog) 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 *LogicalOpLog) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Ops) > 0 {
		for _, msg := range m.Ops {
			dAtA[i] = 0xa
			i++
			i = encodeVarintProposerKv(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *RaftCommand) 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 *RaftCommand) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.MaxLeaseIndex != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.MaxLeaseIndex))
	}
	if m.DeprecatedProposerLease != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.DeprecatedProposerLease.Size()))
		n17, err := m.DeprecatedProposerLease.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if m.ProposerLeaseSequence != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.ProposerLeaseSequence))
	}
	dAtA[i] = 0x6a
	i++
	i = encodeVarintProposerKv(dAtA, i, uint64(m.ReplicatedEvalResult.Size()))
	n18, err := m.ReplicatedEvalResult.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n18
	if m.WriteBatch != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.WriteBatch.Size()))
		n19, err := m.WriteBatch.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	if m.LogicalOpLog != nil {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintProposerKv(dAtA, i, uint64(m.LogicalOpLog.Size()))
		n20, err := m.LogicalOpLog.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	if len(m.TraceData) > 0 {
		keysForTraceData := make([]string, 0, len(m.TraceData))
		for k := range m.TraceData {
			keysForTraceData = append(keysForTraceData, string(k))
		}
		github_com_gogo_protobuf_sortkeys.Strings(keysForTraceData)
		for _, k := range keysForTraceData {
			dAtA[i] = 0x82
			i++
			dAtA[i] = 0x1
			i++
			v := m.TraceData[string(k)]
			mapSize := 1 + len(k) + sovProposerKv(uint64(len(k))) + 1 + len(v) + sovProposerKv(uint64(len(v)))
			i = encodeVarintProposerKv(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintProposerKv(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintProposerKv(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

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

func encodeVarintProposerKv(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 *Split) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.SplitTrigger.Size()
	n += 1 + l + sovProposerKv(uint64(l))
	l = m.RHSDelta.Size()
	n += 1 + l + sovProposerKv(uint64(l))
	return n
}

func (m *Merge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MergeTrigger.Size()
	n += 1 + l + sovProposerKv(uint64(l))
	return n
}

func (m *ChangeReplicas) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ChangeReplicasTrigger.Size()
	n += 1 + l + sovProposerKv(uint64(l))
	return n
}

func (m *ComputeChecksum) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ChecksumID.Size()
	n += 1 + l + sovProposerKv(uint64(l))
	if m.SaveSnapshot {
		n += 2
	}
	if m.Mode != 0 {
		n += 1 + sovProposerKv(uint64(m.Mode))
	}
	if m.Checkpoint {
		n += 2
	}
	if m.Version != 0 {
		n += 1 + sovProposerKv(uint64(m.Version))
	}
	if len(m.Terminate) > 0 {
		for _, e := range m.Terminate {
			l = e.Size()
			n += 1 + l + sovProposerKv(uint64(l))
		}
	}
	return n
}

func (m *Compaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Bytes != 0 {
		n += 1 + sovProposerKv(uint64(m.Bytes))
	}
	if m.SuggestedAtNanos != 0 {
		n += 1 + sovProposerKv(uint64(m.SuggestedAtNanos))
	}
	return n
}

func (m *SuggestedCompaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StartKey)
	if l > 0 {
		n += 1 + l + sovProposerKv(uint64(l))
	}
	l = len(m.EndKey)
	if l > 0 {
		n += 1 + l + sovProposerKv(uint64(l))
	}
	l = m.Compaction.Size()
	n += 1 + l + sovProposerKv(uint64(l))
	return n
}

func (m *ReplicatedEvalResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovProposerKv(uint64(l))
	}
	if m.Split != nil {
		l = m.Split.Size()
		n += 1 + l + sovProposerKv(uint64(l))
	}
	if m.Merge != nil {
		l = m.Merge.Size()
		n += 1 + l + sovProposerKv(uint64(l))
	}
	if m.IsLeaseRequest {
		n += 2
	}
	l = m.Timestamp.Size()
	n += 1 + l + sovProposerKv(uint64(l))
	if m.DeprecatedDelta != nil {
		l = m.DeprecatedDelta.Size()
		n += 1 + l + sovProposerKv(uint64(l))
	}
	if m.ChangeReplicas != nil {
		l = m.ChangeReplicas.Size()
		n += 1 + l + sovProposerKv(uint64(l))
	}
	if m.RaftLogDelta != 0 {
		n += 1 + sovProposerKv(uint64(m.RaftLogDelta))
	}
	if m.AddSSTable != nil {
		l = m.AddSSTable.Size()
		n += 2 + l + sovProposerKv(uint64(l))
	}
	l = m.Delta.Size()
	n += 2 + l + sovProposerKv(uint64(l))
	if len(m.SuggestedCompactions) > 0 {
		for _, e := range m.SuggestedCompactions {
			l = e.Size()
			n += 2 + l + sovProposerKv(uint64(l))
		}
	}
	if m.PrevLeaseProposal != nil {
		l = m.PrevLeaseProposal.Size()
		n += 2 + l + sovProposerKv(uint64(l))
	}
	if m.ComputeChecksum != nil {
		l = m.ComputeChecksum.Size()
		n += 2 + l + sovProposerKv(uint64(l))
	}
	return n
}

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

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

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

func (m *RaftCommand) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MaxLeaseIndex != 0 {
		n += 1 + sovProposerKv(uint64(m.MaxLeaseIndex))
	}
	if m.DeprecatedProposerLease != nil {
		l = m.DeprecatedProposerLease.Size()
		n += 1 + l + sovProposerKv(uint64(l))
	}
	if m.ProposerLeaseSequence != 0 {
		n += 1 + sovProposerKv(uint64(m.ProposerLeaseSequence))
	}
	l = m.ReplicatedEvalResult.Size()
	n += 1 + l + sovProposerKv(uint64(l))
	if m.WriteBatch != nil {
		l = m.WriteBatch.Size()
		n += 1 + l + sovProposerKv(uint64(l))
	}
	if m.LogicalOpLog != nil {
		l = m.LogicalOpLog.Size()
		n += 1 + l + sovProposerKv(uint64(l))
	}
	if len(m.TraceData) > 0 {
		for k, v := range m.TraceData {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovProposerKv(uint64(len(k))) + 1 + len(v) + sovProposerKv(uint64(len(v)))
			n += mapEntrySize + 2 + sovProposerKv(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *RaftCommandFooter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MaxLeaseIndex != 0 {
		n += 1 + sovProposerKv(uint64(m.MaxLeaseIndex))
	}
	return n
}

func sovProposerKv(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozProposerKv(x uint64) (n int) {
	return sovProposerKv(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Split) 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 ErrIntOverflowProposerKv
			}
			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: Split: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Split: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SplitTrigger", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SplitTrigger.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RHSDelta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.RHSDelta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProposerKv(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProposerKv
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ComputeChecksum) 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 ErrIntOverflowProposerKv
			}
			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: ComputeChecksum: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ComputeChecksum: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChecksumID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ChecksumID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SaveSnapshot", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SaveSnapshot = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= (roachpb.ChecksumMode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checkpoint", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Checkpoint = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			m.Version = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Version |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Terminate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Terminate = append(m.Terminate, roachpb.ReplicaDescriptor{})
			if err := m.Terminate[len(m.Terminate)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProposerKv(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProposerKv
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReplicatedEvalResult) 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 ErrIntOverflowProposerKv
			}
			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: ReplicatedEvalResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReplicatedEvalResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			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 ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.State == nil {
				m.State = &ReplicaState{}
			}
			if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Split", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Split == nil {
				m.Split = &Split{}
			}
			if err := m.Split.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Merge", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Merge == nil {
				m.Merge = &Merge{}
			}
			if err := m.Merge.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsLeaseRequest", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsLeaseRequest = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedDelta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DeprecatedDelta == nil {
				m.DeprecatedDelta = &enginepb.MVCCStats{}
			}
			if err := m.DeprecatedDelta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChangeReplicas", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChangeReplicas == nil {
				m.ChangeReplicas = &ChangeReplicas{}
			}
			if err := m.ChangeReplicas.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RaftLogDelta", wireType)
			}
			m.RaftLogDelta = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RaftLogDelta |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AddSSTable", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AddSSTable == nil {
				m.AddSSTable = &ReplicatedEvalResult_AddSSTable{}
			}
			if err := m.AddSSTable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Delta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Delta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SuggestedCompactions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SuggestedCompactions = append(m.SuggestedCompactions, SuggestedCompaction{})
			if err := m.SuggestedCompactions[len(m.SuggestedCompactions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevLeaseProposal", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PrevLeaseProposal == nil {
				m.PrevLeaseProposal = &hlc.Timestamp{}
			}
			if err := m.PrevLeaseProposal.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ComputeChecksum", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ComputeChecksum == nil {
				m.ComputeChecksum = &ComputeChecksum{}
			}
			if err := m.ComputeChecksum.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProposerKv(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProposerKv
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RaftCommand) 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 ErrIntOverflowProposerKv
			}
			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: RaftCommand: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RaftCommand: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxLeaseIndex", wireType)
			}
			m.MaxLeaseIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxLeaseIndex |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeprecatedProposerLease", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DeprecatedProposerLease == nil {
				m.DeprecatedProposerLease = &roachpb.Lease{}
			}
			if err := m.DeprecatedProposerLease.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProposerLeaseSequence", wireType)
			}
			m.ProposerLeaseSequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProposerLeaseSequence |= (github_com_cockroachdb_cockroach_pkg_roachpb.LeaseSequence(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicatedEvalResult", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ReplicatedEvalResult.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WriteBatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WriteBatch == nil {
				m.WriteBatch = &WriteBatch{}
			}
			if err := m.WriteBatch.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogicalOpLog", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LogicalOpLog == nil {
				m.LogicalOpLog = &LogicalOpLog{}
			}
			if err := m.LogicalOpLog.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TraceData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProposerKv
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthProposerKv
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TraceData == nil {
				m.TraceData = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProposerKv
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProposerKv
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthProposerKv
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProposerKv
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= (uint64(b) & 0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthProposerKv
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipProposerKv(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthProposerKv
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.TraceData[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipProposerKv(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthProposerKv
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

func init() {
	proto.RegisterFile("kv/kvserver/kvserverpb/proposer_kv.proto", fileDescriptor_proposer_kv_baa0b8d6d33a3e71)
}

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