proto_rec_ctl.pb.go

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

package rms

import (
	encoding_binary "encoding/binary"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/insolar/assured-ledger/ledger-core/insproto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type RCtlPlashStart struct {
	Version        uint32    `protobuf:"varint,40,opt,name=Version,proto3" json:"Version"`
	NodeRef        Reference `protobuf:"bytes,41,opt,name=NodeRef,proto3" json:"NodeRef"`
	PulseData      Reference `protobuf:"bytes,42,opt,name=PulseData,proto3" json:"PulseData"`
	PulseEpochData Reference `protobuf:"bytes,43,opt,name=PulseEpochData,proto3" json:"PulseEpochData"`
	PopulationRef  Reference `protobuf:"bytes,44,opt,name=PopulationRef,proto3" json:"PopulationRef"`
	Population     Binary    `protobuf:"bytes,45,opt,name=Population,proto3" json:"Population"`
}

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

var xxx_messageInfo_RCtlPlashStart proto.InternalMessageInfo

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

func (m *RCtlPlashStart) GetNodeRef() Reference {
	if m != nil {
		return m.NodeRef
	}
	return Reference{}
}

func (m *RCtlPlashStart) GetPulseData() Reference {
	if m != nil {
		return m.PulseData
	}
	return Reference{}
}

func (m *RCtlPlashStart) GetPulseEpochData() Reference {
	if m != nil {
		return m.PulseEpochData
	}
	return Reference{}
}

func (m *RCtlPlashStart) GetPopulationRef() Reference {
	if m != nil {
		return m.PopulationRef
	}
	return Reference{}
}

func (m *RCtlPlashStart) GetPopulation() Binary {
	if m != nil {
		return m.Population
	}
	return Binary{}
}

type RCtlPlashSummary struct {
	MerkleRoot              Binary           `protobuf:"bytes,40,opt,name=MerkleRoot,proto3" json:"MerkleRoot"`
	MerkleProducerSignature Binary           `protobuf:"bytes,41,opt,name=MerkleProducerSignature,proto3" json:"MerkleProducerSignature"`
	SectionSummaryOrd       []CatalogOrdinal `protobuf:"varint,50,rep,packed,name=SectionSummaryOrd,proto3,casttype=CatalogOrdinal" json:"SectionSummaryOrd,omitempty"`
	DropSummaryOrd          []CatalogOrdinal `protobuf:"varint,51,rep,packed,name=DropSummaryOrd,proto3,casttype=CatalogOrdinal" json:"DropSummaryOrd,omitempty"`
}

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

var xxx_messageInfo_RCtlPlashSummary proto.InternalMessageInfo

func (m *RCtlPlashSummary) GetMerkleRoot() Binary {
	if m != nil {
		return m.MerkleRoot
	}
	return Binary{}
}

func (m *RCtlPlashSummary) GetMerkleProducerSignature() Binary {
	if m != nil {
		return m.MerkleProducerSignature
	}
	return Binary{}
}

func (m *RCtlPlashSummary) GetSectionSummaryOrd() []CatalogOrdinal {
	if m != nil {
		return m.SectionSummaryOrd
	}
	return nil
}

func (m *RCtlPlashSummary) GetDropSummaryOrd() []CatalogOrdinal {
	if m != nil {
		return m.DropSummaryOrd
	}
	return nil
}

type RCtlDropSummary struct {
	DropReport              RCtlDropReport `protobuf:"bytes,40,opt,name=DropReport,proto3" json:"DropReport"`
	ReportProducerSignature Binary         `protobuf:"bytes,41,opt,name=ReportProducerSignature,proto3" json:"ReportProducerSignature"`
	MerkleLogLoc            StorageLocator `protobuf:"fixed64,44,opt,name=MerkleLogLoc,proto3,casttype=StorageLocator" json:"MerkleLogLoc"`
	MerkleLogSize           uint32         `protobuf:"varint,45,opt,name=MerkleLogSize,proto3" json:"MerkleLogSize"`
	MerkleLogCount          uint32         `protobuf:"varint,46,opt,name=MerkleLogCount,proto3" json:"MerkleLogCount"`
}

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

var xxx_messageInfo_RCtlDropSummary proto.InternalMessageInfo

func (m *RCtlDropSummary) GetDropReport() RCtlDropReport {
	if m != nil {
		return m.DropReport
	}
	return RCtlDropReport{}
}

func (m *RCtlDropSummary) GetReportProducerSignature() Binary {
	if m != nil {
		return m.ReportProducerSignature
	}
	return Binary{}
}

func (m *RCtlDropSummary) GetMerkleLogLoc() StorageLocator {
	if m != nil {
		return m.MerkleLogLoc
	}
	return 0
}

func (m *RCtlDropSummary) GetMerkleLogSize() uint32 {
	if m != nil {
		return m.MerkleLogSize
	}
	return 0
}

func (m *RCtlDropSummary) GetMerkleLogCount() uint32 {
	if m != nil {
		return m.MerkleLogCount
	}
	return 0
}

type RCtlSectionSummary struct {
	RecToFilLoc   StorageLocator `protobuf:"fixed64,40,opt,name=RecToFilLoc,proto3,casttype=StorageLocator" json:"RecToFilLoc"`
	RecToFilSize  uint32         `protobuf:"varint,41,opt,name=RecToFilSize,proto3" json:"RecToFilSize"`
	FilToJetLoc   StorageLocator `protobuf:"fixed64,42,opt,name=FilToJetLoc,proto3,casttype=StorageLocator" json:"FilToJetLoc"`
	FilToJetSize  uint32         `protobuf:"varint,43,opt,name=FilToJetSize,proto3" json:"FilToJetSize"`
	RecToNextLoc  StorageLocator `protobuf:"fixed64,44,opt,name=RecToNextLoc,proto3,casttype=StorageLocator" json:"RecToNextLoc"`
	RecToNextSize uint32         `protobuf:"varint,45,opt,name=RecToNextSize,proto3" json:"RecToNextSize"`
}

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

var xxx_messageInfo_RCtlSectionSummary proto.InternalMessageInfo

func (m *RCtlSectionSummary) GetRecToFilLoc() StorageLocator {
	if m != nil {
		return m.RecToFilLoc
	}
	return 0
}

func (m *RCtlSectionSummary) GetRecToFilSize() uint32 {
	if m != nil {
		return m.RecToFilSize
	}
	return 0
}

func (m *RCtlSectionSummary) GetFilToJetLoc() StorageLocator {
	if m != nil {
		return m.FilToJetLoc
	}
	return 0
}

func (m *RCtlSectionSummary) GetFilToJetSize() uint32 {
	if m != nil {
		return m.FilToJetSize
	}
	return 0
}

func (m *RCtlSectionSummary) GetRecToNextLoc() StorageLocator {
	if m != nil {
		return m.RecToNextLoc
	}
	return 0
}

func (m *RCtlSectionSummary) GetRecToNextSize() uint32 {
	if m != nil {
		return m.RecToNextSize
	}
	return 0
}

type RCtlFilamentUpdate struct {
}

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

var xxx_messageInfo_RCtlFilamentUpdate proto.InternalMessageInfo

type RCtlFilamentEntry struct {
	// LastKnownPN is an in-place MUTABLE field
	LastKnownPN             PulseNumber  `protobuf:"fixed32,19,opt,name=LastKnownPN,proto3,casttype=PulseNumber" json:"LastKnownPN"`
	LineRecap               RLineRecap   `protobuf:"bytes,41,opt,name=LineRecap,proto3" json:"LineRecap"`
	RecapProducerSignature  Binary       `protobuf:"bytes,42,opt,name=RecapProducerSignature,proto3" json:"RecapProducerSignature"`
	LineReport              RStateReport `protobuf:"bytes,43,opt,name=LineReport,proto3" json:"LineReport"`
	ReportProducerSignature Binary       `protobuf:"bytes,44,opt,name=ReportProducerSignature,proto3" json:"ReportProducerSignature"`
}

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

var xxx_messageInfo_RCtlFilamentEntry proto.InternalMessageInfo

func (m *RCtlFilamentEntry) GetLastKnownPN() PulseNumber {
	if m != nil {
		return m.LastKnownPN
	}
	return 0
}

func (m *RCtlFilamentEntry) GetLineRecap() RLineRecap {
	if m != nil {
		return m.LineRecap
	}
	return RLineRecap{}
}

func (m *RCtlFilamentEntry) GetRecapProducerSignature() Binary {
	if m != nil {
		return m.RecapProducerSignature
	}
	return Binary{}
}

func (m *RCtlFilamentEntry) GetLineReport() RStateReport {
	if m != nil {
		return m.LineReport
	}
	return RStateReport{}
}

func (m *RCtlFilamentEntry) GetReportProducerSignature() Binary {
	if m != nil {
		return m.ReportProducerSignature
	}
	return Binary{}
}

type RCtlDropReport struct {
	PulseNumber     PulseNumber `protobuf:"fixed32,40,opt,name=PulseNumber,proto3,casttype=PulseNumber" json:"PulseNumber"`
	JetLegID        JetLegID    `protobuf:"fixed64,41,opt,name=JetLegID,proto3,casttype=JetLegID" json:"JetLegID"`
	MerkleRoot      Binary      `protobuf:"bytes,42,opt,name=MerkleRoot,proto3" json:"MerkleRoot"`
	PrevPulseNumber PulseNumber `protobuf:"fixed32,50,opt,name=PrevPulseNumber,proto3,casttype=PulseNumber" json:"PrevPulseNumber"`
	PrevJetLegID    JetLegID    `protobuf:"fixed64,51,opt,name=PrevJetLegID,proto3,casttype=JetLegID" json:"PrevJetLegID"`
	PrevMerkleRoot  Binary      `protobuf:"bytes,52,opt,name=PrevMerkleRoot,proto3" json:"PrevMerkleRoot"`
	// pulse
	// population
	ProducedBy Reference `protobuf:"bytes,60,opt,name=ProducedBy,proto3" json:"ProducedBy"`
}

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

var xxx_messageInfo_RCtlDropReport proto.InternalMessageInfo

func (m *RCtlDropReport) GetPulseNumber() PulseNumber {
	if m != nil {
		return m.PulseNumber
	}
	return 0
}

func (m *RCtlDropReport) GetJetLegID() JetLegID {
	if m != nil {
		return m.JetLegID
	}
	return 0
}

func (m *RCtlDropReport) GetMerkleRoot() Binary {
	if m != nil {
		return m.MerkleRoot
	}
	return Binary{}
}

func (m *RCtlDropReport) GetPrevPulseNumber() PulseNumber {
	if m != nil {
		return m.PrevPulseNumber
	}
	return 0
}

func (m *RCtlDropReport) GetPrevJetLegID() JetLegID {
	if m != nil {
		return m.PrevJetLegID
	}
	return 0
}

func (m *RCtlDropReport) GetPrevMerkleRoot() Binary {
	if m != nil {
		return m.PrevMerkleRoot
	}
	return Binary{}
}

func (m *RCtlDropReport) GetProducedBy() Reference {
	if m != nil {
		return m.ProducedBy
	}
	return Reference{}
}

type RStateReport struct {
}

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

var xxx_messageInfo_RStateReport proto.InternalMessageInfo

func init() {
	proto.RegisterType((*RCtlPlashStart)(nil), "rms.RCtlPlashStart")
	proto.RegisterType((*RCtlPlashSummary)(nil), "rms.RCtlPlashSummary")
	proto.RegisterType((*RCtlDropSummary)(nil), "rms.RCtlDropSummary")
	proto.RegisterType((*RCtlSectionSummary)(nil), "rms.RCtlSectionSummary")
	proto.RegisterType((*RCtlFilamentUpdate)(nil), "rms.RCtlFilamentUpdate")
	proto.RegisterType((*RCtlFilamentEntry)(nil), "rms.RCtlFilamentEntry")
	proto.RegisterType((*RCtlDropReport)(nil), "rms.RCtlDropReport")
	proto.RegisterType((*RStateReport)(nil), "rms.RStateReport")
}

func init() { proto.RegisterFile("proto_rec_ctl.proto", fileDescriptor_f042488a06be6910) }

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

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

	that1, ok := that.(*RCtlPlashStart)
	if !ok {
		that2, ok := that.(RCtlPlashStart)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Version != that1.Version {
		return false
	}
	if !this.NodeRef.Equal(&that1.NodeRef) {
		return false
	}
	if !this.PulseData.Equal(&that1.PulseData) {
		return false
	}
	if !this.PulseEpochData.Equal(&that1.PulseEpochData) {
		return false
	}
	if !this.PopulationRef.Equal(&that1.PopulationRef) {
		return false
	}
	if !this.Population.Equal(&that1.Population) {
		return false
	}
	return true
}
func (this *RCtlPlashSummary) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RCtlPlashSummary)
	if !ok {
		that2, ok := that.(RCtlPlashSummary)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.MerkleRoot.Equal(&that1.MerkleRoot) {
		return false
	}
	if !this.MerkleProducerSignature.Equal(&that1.MerkleProducerSignature) {
		return false
	}
	if len(this.SectionSummaryOrd) != len(that1.SectionSummaryOrd) {
		return false
	}
	for i := range this.SectionSummaryOrd {
		if this.SectionSummaryOrd[i] != that1.SectionSummaryOrd[i] {
			return false
		}
	}
	if len(this.DropSummaryOrd) != len(that1.DropSummaryOrd) {
		return false
	}
	for i := range this.DropSummaryOrd {
		if this.DropSummaryOrd[i] != that1.DropSummaryOrd[i] {
			return false
		}
	}
	return true
}
func (this *RCtlDropSummary) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RCtlDropSummary)
	if !ok {
		that2, ok := that.(RCtlDropSummary)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.DropReport.Equal(&that1.DropReport) {
		return false
	}
	if !this.ReportProducerSignature.Equal(&that1.ReportProducerSignature) {
		return false
	}
	if this.MerkleLogLoc != that1.MerkleLogLoc {
		return false
	}
	if this.MerkleLogSize != that1.MerkleLogSize {
		return false
	}
	if this.MerkleLogCount != that1.MerkleLogCount {
		return false
	}
	return true
}
func (this *RCtlSectionSummary) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RCtlSectionSummary)
	if !ok {
		that2, ok := that.(RCtlSectionSummary)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.RecToFilLoc != that1.RecToFilLoc {
		return false
	}
	if this.RecToFilSize != that1.RecToFilSize {
		return false
	}
	if this.FilToJetLoc != that1.FilToJetLoc {
		return false
	}
	if this.FilToJetSize != that1.FilToJetSize {
		return false
	}
	if this.RecToNextLoc != that1.RecToNextLoc {
		return false
	}
	if this.RecToNextSize != that1.RecToNextSize {
		return false
	}
	return true
}
func (this *RCtlFilamentUpdate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*RCtlFilamentEntry)
	if !ok {
		that2, ok := that.(RCtlFilamentEntry)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.LastKnownPN != that1.LastKnownPN {
		return false
	}
	if !this.LineRecap.Equal(&that1.LineRecap) {
		return false
	}
	if !this.RecapProducerSignature.Equal(&that1.RecapProducerSignature) {
		return false
	}
	if !this.LineReport.Equal(&that1.LineReport) {
		return false
	}
	if !this.ReportProducerSignature.Equal(&that1.ReportProducerSignature) {
		return false
	}
	return true
}
func (this *RCtlDropReport) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RCtlDropReport)
	if !ok {
		that2, ok := that.(RCtlDropReport)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.PulseNumber != that1.PulseNumber {
		return false
	}
	if this.JetLegID != that1.JetLegID {
		return false
	}
	if !this.MerkleRoot.Equal(&that1.MerkleRoot) {
		return false
	}
	if this.PrevPulseNumber != that1.PrevPulseNumber {
		return false
	}
	if this.PrevJetLegID != that1.PrevJetLegID {
		return false
	}
	if !this.PrevMerkleRoot.Equal(&that1.PrevMerkleRoot) {
		return false
	}
	if !this.ProducedBy.Equal(&that1.ProducedBy) {
		return false
	}
	return true
}
func (this *RStateReport) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RStateReport)
	if !ok {
		that2, ok := that.(RStateReport)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	return true
}

const TypeRCtlPlashStartPolymorphID = 100

func (*RCtlPlashStart) GetDefaultPolymorphID() uint64 {
	return 100
}

func (m *RCtlPlashStart) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *RCtlPlashStart) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	{
		size, err := m.Population.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xea
		}
	}
	{
		size, err := m.PopulationRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xe2
		}
	}
	{
		size, err := m.PulseEpochData.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xda
		}
	}
	{
		size, err := m.PulseData.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xd2
		}
	}
	{
		size, err := m.NodeRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xca
		}
	}
	if m.Version != 0 {
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(m.Version))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc0
	}
	i = encodeVarintProtoRecCtl(dAtA, i, uint64(100))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	return len(dAtA) - i, nil
}

const TypeRCtlPlashSummaryPolymorphID = 101

func (*RCtlPlashSummary) GetDefaultPolymorphID() uint64 {
	return 101
}

func (m *RCtlPlashSummary) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *RCtlPlashSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	if len(m.DropSummaryOrd) > 0 {
		dAtA7 := make([]byte, len(m.DropSummaryOrd)*10)
		var j6 int
		for _, num := range m.DropSummaryOrd {
			for num >= 1<<7 {
				dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j6++
			}
			dAtA7[j6] = uint8(num)
			j6++
		}
		i -= j6
		copy(dAtA[i:], dAtA7[:j6])
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(j6))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x9a
	}
	if len(m.SectionSummaryOrd) > 0 {
		dAtA9 := make([]byte, len(m.SectionSummaryOrd)*10)
		var j8 int
		for _, num := range m.SectionSummaryOrd {
			for num >= 1<<7 {
				dAtA9[j8] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j8++
			}
			dAtA9[j8] = uint8(num)
			j8++
		}
		i -= j8
		copy(dAtA[i:], dAtA9[:j8])
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(j8))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x92
	}
	{
		size, err := m.MerkleProducerSignature.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.MerkleRoot.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xc2
		}
	}
	i = encodeVarintProtoRecCtl(dAtA, i, uint64(101))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	return len(dAtA) - i, nil
}

const TypeRCtlDropSummaryPolymorphID = 102

func (*RCtlDropSummary) GetDefaultPolymorphID() uint64 {
	return 102
}

func (m *RCtlDropSummary) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *RCtlDropSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	if m.MerkleLogCount != 0 {
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(m.MerkleLogCount))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xf0
	}
	if m.MerkleLogSize != 0 {
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(m.MerkleLogSize))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xe8
	}
	if m.MerkleLogLoc != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.MerkleLogLoc))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xe1
	}
	{
		size, err := m.ReportProducerSignature.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.DropReport.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xc2
		}
	}
	i = encodeVarintProtoRecCtl(dAtA, i, uint64(102))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	return len(dAtA) - i, nil
}

const TypeRCtlSectionSummaryPolymorphID = 104

func (*RCtlSectionSummary) GetDefaultPolymorphID() uint64 {
	return 104
}

func (m *RCtlSectionSummary) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *RCtlSectionSummary) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	if m.RecToNextSize != 0 {
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(m.RecToNextSize))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xe8
	}
	if m.RecToNextLoc != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RecToNextLoc))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xe1
	}
	if m.FilToJetSize != 0 {
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(m.FilToJetSize))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd8
	}
	if m.FilToJetLoc != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.FilToJetLoc))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd1
	}
	if m.RecToFilSize != 0 {
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(m.RecToFilSize))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc8
	}
	if m.RecToFilLoc != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.RecToFilLoc))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc1
	}
	i = encodeVarintProtoRecCtl(dAtA, i, uint64(104))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	return len(dAtA) - i, nil
}

const TypeRCtlFilamentUpdatePolymorphID = 105

func (*RCtlFilamentUpdate) GetDefaultPolymorphID() uint64 {
	return 105
}

func (m *RCtlFilamentUpdate) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *RCtlFilamentUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	i = encodeVarintProtoRecCtl(dAtA, i, uint64(105))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	return len(dAtA) - i, nil
}

func (m *RCtlFilamentEntry) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *RCtlFilamentEntry) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	{
		size, err := m.ReportProducerSignature.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xe2
		}
	}
	{
		size, err := m.LineReport.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xda
		}
	}
	{
		size, err := m.RecapProducerSignature.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xd2
		}
	}
	{
		size, err := m.LineRecap.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xca
		}
	}
	i -= 4
	encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.LastKnownPN))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x9d
	return len(dAtA) - i, nil
}

func (m *RCtlDropReport) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *RCtlDropReport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	{
		size, err := m.ProducedBy.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xe2
		}
	}
	{
		size, err := m.PrevMerkleRoot.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xa2
		}
	}
	if m.PrevJetLegID != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.PrevJetLegID))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x99
	}
	if m.PrevPulseNumber != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.PrevPulseNumber))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0x95
	}
	{
		size, err := m.MerkleRoot.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecCtl(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xd2
		}
	}
	if m.JetLegID != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(m.JetLegID))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc9
	}
	if m.PulseNumber != 0 {
		i -= 4
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.PulseNumber))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc5
	}
	if i < len(dAtA) {
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(0))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	return len(dAtA) - i, nil
}

func (m *RStateReport) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	if n != size {
		panic("illegal state")
	}
	return dAtA[:n], nil
}

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

func (m *RStateReport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	if i < len(dAtA) {
		i = encodeVarintProtoRecCtl(dAtA, i, uint64(0))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	return len(dAtA) - i, nil
}

func encodeVarintProtoRecCtl(dAtA []byte, offset int, v uint64) int {
	offset -= sovProtoRecCtl(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

func (m *RCtlPlashStart) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Version != 0 {
		n += 2 + sovProtoRecCtl(uint64(m.Version))
	}
	if l = m.NodeRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.PulseData.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.PulseEpochData.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.PopulationRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.Population.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	n += 2 + sovProtoRecCtl(100)
	return n
}

func (m *RCtlPlashSummary) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.MerkleRoot.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.MerkleProducerSignature.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if len(m.SectionSummaryOrd) > 0 {
		l = 0
		for _, e := range m.SectionSummaryOrd {
			l += sovProtoRecCtl(uint64(e))
		}
		n += 2 + sovProtoRecCtl(uint64(l)) + l
	}
	if len(m.DropSummaryOrd) > 0 {
		l = 0
		for _, e := range m.DropSummaryOrd {
			l += sovProtoRecCtl(uint64(e))
		}
		n += 2 + sovProtoRecCtl(uint64(l)) + l
	}
	n += 2 + sovProtoRecCtl(101)
	return n
}

func (m *RCtlDropSummary) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.DropReport.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.ReportProducerSignature.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if m.MerkleLogLoc != 0 {
		n += 10
	}
	if m.MerkleLogSize != 0 {
		n += 2 + sovProtoRecCtl(uint64(m.MerkleLogSize))
	}
	if m.MerkleLogCount != 0 {
		n += 2 + sovProtoRecCtl(uint64(m.MerkleLogCount))
	}
	n += 2 + sovProtoRecCtl(102)
	return n
}

func (m *RCtlSectionSummary) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.RecToFilLoc != 0 {
		n += 10
	}
	if m.RecToFilSize != 0 {
		n += 2 + sovProtoRecCtl(uint64(m.RecToFilSize))
	}
	if m.FilToJetLoc != 0 {
		n += 10
	}
	if m.FilToJetSize != 0 {
		n += 2 + sovProtoRecCtl(uint64(m.FilToJetSize))
	}
	if m.RecToNextLoc != 0 {
		n += 10
	}
	if m.RecToNextSize != 0 {
		n += 2 + sovProtoRecCtl(uint64(m.RecToNextSize))
	}
	n += 2 + sovProtoRecCtl(104)
	return n
}

func (m *RCtlFilamentUpdate) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 2 + sovProtoRecCtl(105)
	return n
}

func (m *RCtlFilamentEntry) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	n += 6
	if l = m.LineRecap.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.RecapProducerSignature.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.LineReport.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.ReportProducerSignature.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	return n
}

func (m *RCtlDropReport) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PulseNumber != 0 {
		n += 6
	}
	if m.JetLegID != 0 {
		n += 10
	}
	if l = m.MerkleRoot.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if m.PrevPulseNumber != 0 {
		n += 6
	}
	if m.PrevJetLegID != 0 {
		n += 10
	}
	if l = m.PrevMerkleRoot.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if l = m.ProducedBy.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecCtl(uint64(l))
	}
	if n > 0 {
		n += 2 + sovProtoRecCtl(0)
	}
	return n
}

func (m *RStateReport) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if n > 0 {
		n += 2 + sovProtoRecCtl(0)
	}
	return n
}

func sovProtoRecCtl(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozProtoRecCtl(x uint64) (n int) {
	return sovProtoRecCtl(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RCtlPlashStart) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecCtl)
	return err
}
func (m *RCtlPlashStart) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoRecCtl
				}
				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: RCtlPlashStart: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RCtlPlashStart: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 40:
				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 ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.Version |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 41:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field NodeRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.NodeRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 42:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PulseData", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PulseData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 43:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PulseEpochData", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PulseEpochData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 44:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PopulationRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PopulationRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 45:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Population", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.Population.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoRecCtl(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	return iNdEx, nil
}
func (m *RCtlPlashSummary) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecCtl)
	return err
}
func (m *RCtlPlashSummary) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoRecCtl
				}
				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: RCtlPlashSummary: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RCtlPlashSummary: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 40:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field MerkleRoot", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.MerkleRoot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 41:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field MerkleProducerSignature", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.MerkleProducerSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 50:
				if wireType == 0 {
					var v CatalogOrdinal
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProtoRecCtl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= CatalogOrdinal(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.SectionSummaryOrd = append(m.SectionSummaryOrd, v)
				} else if wireType == 2 {
					var packedLen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProtoRecCtl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						packedLen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if packedLen < 0 {
						return ErrInvalidLengthProtoRecCtl
					}
					postIndex := iNdEx + packedLen
					if postIndex < 0 {
						return ErrInvalidLengthProtoRecCtl
					}
					if postIndex > l {
						return io.ErrUnexpectedEOF
					}
					var elementCount int
					var count int
					for _, integer := range dAtA[iNdEx:postIndex] {
						if integer < 128 {
							count++
						}
					}
					elementCount = count
					if elementCount != 0 && len(m.SectionSummaryOrd) == 0 {
						m.SectionSummaryOrd = make([]CatalogOrdinal, 0, elementCount)
					}
					for iNdEx < postIndex {
						var v CatalogOrdinal
						for shift := uint(0); ; shift += 7 {
							if shift >= 64 {
								return ErrIntOverflowProtoRecCtl
							}
							if iNdEx >= l {
								return io.ErrUnexpectedEOF
							}
							b := dAtA[iNdEx]
							iNdEx++
							v |= CatalogOrdinal(b&0x7F) << shift
							if b < 0x80 {
								break
							}
						}
						m.SectionSummaryOrd = append(m.SectionSummaryOrd, v)
					}
				} else {
					return fmt.Errorf("proto: wrong wireType = %d for field SectionSummaryOrd", wireType)
				}
			case 51:
				if wireType == 0 {
					var v CatalogOrdinal
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProtoRecCtl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= CatalogOrdinal(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.DropSummaryOrd = append(m.DropSummaryOrd, v)
				} else if wireType == 2 {
					var packedLen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowProtoRecCtl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						packedLen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if packedLen < 0 {
						return ErrInvalidLengthProtoRecCtl
					}
					postIndex := iNdEx + packedLen
					if postIndex < 0 {
						return ErrInvalidLengthProtoRecCtl
					}
					if postIndex > l {
						return io.ErrUnexpectedEOF
					}
					var elementCount int
					var count int
					for _, integer := range dAtA[iNdEx:postIndex] {
						if integer < 128 {
							count++
						}
					}
					elementCount = count
					if elementCount != 0 && len(m.DropSummaryOrd) == 0 {
						m.DropSummaryOrd = make([]CatalogOrdinal, 0, elementCount)
					}
					for iNdEx < postIndex {
						var v CatalogOrdinal
						for shift := uint(0); ; shift += 7 {
							if shift >= 64 {
								return ErrIntOverflowProtoRecCtl
							}
							if iNdEx >= l {
								return io.ErrUnexpectedEOF
							}
							b := dAtA[iNdEx]
							iNdEx++
							v |= CatalogOrdinal(b&0x7F) << shift
							if b < 0x80 {
								break
							}
						}
						m.DropSummaryOrd = append(m.DropSummaryOrd, v)
					}
				} else {
					return fmt.Errorf("proto: wrong wireType = %d for field DropSummaryOrd", wireType)
				}
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoRecCtl(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	return iNdEx, nil
}
func (m *RCtlDropSummary) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecCtl)
	return err
}
func (m *RCtlDropSummary) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoRecCtl
				}
				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: RCtlDropSummary: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RCtlDropSummary: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 40:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field DropReport", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.DropReport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 41:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field ReportProducerSignature", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.ReportProducerSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 44:
				if wireType != 1 {
					return fmt.Errorf("proto: wrong wireType = %d for field MerkleLogLoc", wireType)
				}
				m.MerkleLogLoc = 0
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				m.MerkleLogLoc = StorageLocator(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
			case 45:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field MerkleLogSize", wireType)
				}
				m.MerkleLogSize = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.MerkleLogSize |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 46:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field MerkleLogCount", wireType)
				}
				m.MerkleLogCount = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.MerkleLogCount |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoRecCtl(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	return iNdEx, nil
}
func (m *RCtlSectionSummary) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecCtl)
	return err
}
func (m *RCtlSectionSummary) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoRecCtl
				}
				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: RCtlSectionSummary: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RCtlSectionSummary: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 40:
				if wireType != 1 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecToFilLoc", wireType)
				}
				m.RecToFilLoc = 0
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				m.RecToFilLoc = StorageLocator(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
			case 41:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecToFilSize", wireType)
				}
				m.RecToFilSize = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.RecToFilSize |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 42:
				if wireType != 1 {
					return fmt.Errorf("proto: wrong wireType = %d for field FilToJetLoc", wireType)
				}
				m.FilToJetLoc = 0
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				m.FilToJetLoc = StorageLocator(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
			case 43:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field FilToJetSize", wireType)
				}
				m.FilToJetSize = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.FilToJetSize |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 44:
				if wireType != 1 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecToNextLoc", wireType)
				}
				m.RecToNextLoc = 0
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				m.RecToNextLoc = StorageLocator(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
			case 45:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecToNextSize", wireType)
				}
				m.RecToNextSize = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.RecToNextSize |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoRecCtl(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	return iNdEx, nil
}
func (m *RCtlFilamentUpdate) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecCtl)
	return err
}
func (m *RCtlFilamentUpdate) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoRecCtl
				}
				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: RCtlFilamentUpdate: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RCtlFilamentUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoRecCtl(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	return iNdEx, nil
}
func (m *RCtlFilamentEntry) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecCtl)
	return err
}
func (m *RCtlFilamentEntry) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoRecCtl
				}
				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: RCtlFilamentEntry: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RCtlFilamentEntry: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 19:
				if wireType != 5 {
					return fmt.Errorf("proto: wrong wireType = %d for field LastKnownPN", wireType)
				}
				m.LastKnownPN = 0
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				m.LastKnownPN = PulseNumber(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
			case 41:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field LineRecap", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.LineRecap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 42:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecapProducerSignature", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecapProducerSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 43:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field LineReport", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.LineReport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 44:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field ReportProducerSignature", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.ReportProducerSignature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoRecCtl(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	return iNdEx, nil
}
func (m *RCtlDropReport) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecCtl)
	return err
}
func (m *RCtlDropReport) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoRecCtl
				}
				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: RCtlDropReport: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RCtlDropReport: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 40:
				if wireType != 5 {
					return fmt.Errorf("proto: wrong wireType = %d for field PulseNumber", wireType)
				}
				m.PulseNumber = 0
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				m.PulseNumber = PulseNumber(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
			case 41:
				if wireType != 1 {
					return fmt.Errorf("proto: wrong wireType = %d for field JetLegID", wireType)
				}
				m.JetLegID = 0
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				m.JetLegID = JetLegID(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
			case 42:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field MerkleRoot", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.MerkleRoot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 50:
				if wireType != 5 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevPulseNumber", wireType)
				}
				m.PrevPulseNumber = 0
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				m.PrevPulseNumber = PulseNumber(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
			case 51:
				if wireType != 1 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevJetLegID", wireType)
				}
				m.PrevJetLegID = 0
				if (iNdEx + 8) > l {
					return io.ErrUnexpectedEOF
				}
				m.PrevJetLegID = JetLegID(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
				iNdEx += 8
			case 52:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevMerkleRoot", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevMerkleRoot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 60:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field ProducedBy", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecCtl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.ProducedBy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoRecCtl(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	return iNdEx, nil
}
func (m *RStateReport) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecCtl)
	return err
}
func (m *RStateReport) UnmarshalWithUnknownCallback(dAtA []byte, skipFn func([]byte) (int, error)) (int, error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		err := func() error {
			var wire uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowProtoRecCtl
				}
				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: RStateReport: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RStateReport: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			default:
				iNdEx = preIndex
				skippy, err := skipFn(dAtA[iNdEx:])
				if err != nil {
					return err
				}
				if skippy < 0 {
					l = iNdEx
					break
				}
				if skippy == 0 {
					if skippy, err = skipProtoRecCtl(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecCtl
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

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

var (
	ErrInvalidLengthProtoRecCtl        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtoRecCtl          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupProtoRecCtl = fmt.Errorf("proto: unexpected end of group")
	ErrExpectedBinaryMarkerProtoRecCtl = fmt.Errorf("proto: binary marker was expected")
)