proto_records.pb.go

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

package rms

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_insolar_assured_ledger_ledger_core_insproto "github.com/insolar/assured-ledger/ledger-core/insproto"
	insproto "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 FilamentState int32

const (
	FilamentState_Unknown  FilamentState = 0
	FilamentState_Lifeline FilamentState = 1
	FilamentState_Sideline FilamentState = 2
	FilamentState_Call     FilamentState = 3
	// SAGA
	// Listing
	// Timers
	FilamentState_FilamentTypeMask FilamentState = 127
	FilamentState_ActivatedFlag    FilamentState = 4096
	FilamentState_ClosedFlag       FilamentState = 8192
)

var FilamentState_name = map[int32]string{
	0:    "Unknown",
	1:    "Lifeline",
	2:    "Sideline",
	3:    "Call",
	127:  "FilamentTypeMask",
	4096: "ActivatedFlag",
	8192: "ClosedFlag",
}

var FilamentState_value = map[string]int32{
	"Unknown":          0,
	"Lifeline":         1,
	"Sideline":         2,
	"Call":             3,
	"FilamentTypeMask": 127,
	"ActivatedFlag":    4096,
	"ClosedFlag":       8192,
}

func (x FilamentState) String() string {
	return proto.EnumName(FilamentState_name, int32(x))
}

func (FilamentState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f41a5838de60d5c2, []int{0}
}

type SafetyLevel int32

const (
	SafetyLevel_UnknownSafety SafetyLevel = 0
	SafetyLevel_Committed     SafetyLevel = 1
	SafetyLevel_Validated     SafetyLevel = 2
	SafetyLevel_Finalized     SafetyLevel = 3
)

var SafetyLevel_name = map[int32]string{
	0: "UnknownSafety",
	1: "Committed",
	2: "Validated",
	3: "Finalized",
}

var SafetyLevel_value = map[string]int32{
	"UnknownSafety": 0,
	"Committed":     1,
	"Validated":     2,
	"Finalized":     3,
}

func (x SafetyLevel) String() string {
	return proto.EnumName(SafetyLevel_name, int32(x))
}

func (SafetyLevel) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f41a5838de60d5c2, []int{1}
}

type RecordExample struct {
	Polymorph  uint32 `protobuf:"varint,16,opt,name=Polymorph,proto3" json:"Polymorph"`
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	// Add custom fields here
	Str      Binary             `protobuf:"bytes,40,opt,name=Str,proto3" json:"Str"`
	Ref1     Reference          `protobuf:"bytes,41,opt,name=Ref1,proto3" json:"Ref1"`
	AsOf     PulseNumber        `protobuf:"varint,42,opt,name=AsOf,proto3,casttype=PulseNumber" json:"AsOf"`
	FieldMap *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_RecordExample proto.InternalMessageInfo

func (m *RecordExample) GetPolymorph() uint32 {
	if m != nil {
		return m.Polymorph
	}
	return 0
}

func (m *RecordExample) GetStr() Binary {
	if m != nil {
		return m.Str
	}
	return Binary{}
}

func (m *RecordExample) GetRef1() Reference {
	if m != nil {
		return m.Ref1
	}
	return Reference{}
}

func (m *RecordExample) GetAsOf() PulseNumber {
	if m != nil {
		return m.AsOf
	}
	return 0
}

func (m *RecordExample) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type RLineRecap struct {
	RecordBody      `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	PrevRef         Reference          `protobuf:"bytes,24,opt,name=PrevRef,proto3" json:"PrevRef"`
	RootRef         Reference          `protobuf:"bytes,25,opt,name=RootRef,proto3" json:"RootRef"`
	State           FilamentState      `protobuf:"varint,40,opt,name=State,proto3,enum=rms.FilamentState" json:"State"`
	ContinuedFrom   PulseNumber        `protobuf:"varint,41,opt,name=ContinuedFrom,proto3,casttype=PulseNumber" json:"ContinuedFrom"`
	PrevType        uint32             `protobuf:"varint,43,opt,name=PrevType,proto3" json:"PrevType"`
	RedirectToType  uint32             `protobuf:"varint,44,opt,name=RedirectToType,proto3" json:"RedirectToType"`
	PrevRedirectRef Reference          `protobuf:"bytes,45,opt,name=PrevRedirectRef,proto3" json:"PrevRedirectRef"`
	Runnable        []RunnableState    `protobuf:"bytes,50,rep,name=Runnable,proto3" json:"Runnable"`
	FieldMap        *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_RLineRecap proto.InternalMessageInfo

func (m *RLineRecap) GetPrevRef() Reference {
	if m != nil {
		return m.PrevRef
	}
	return Reference{}
}

func (m *RLineRecap) GetRootRef() Reference {
	if m != nil {
		return m.RootRef
	}
	return Reference{}
}

func (m *RLineRecap) GetState() FilamentState {
	if m != nil {
		return m.State
	}
	return FilamentState_Unknown
}

func (m *RLineRecap) GetContinuedFrom() PulseNumber {
	if m != nil {
		return m.ContinuedFrom
	}
	return 0
}

func (m *RLineRecap) GetPrevType() uint32 {
	if m != nil {
		return m.PrevType
	}
	return 0
}

func (m *RLineRecap) GetRedirectToType() uint32 {
	if m != nil {
		return m.RedirectToType
	}
	return 0
}

func (m *RLineRecap) GetPrevRedirectRef() Reference {
	if m != nil {
		return m.PrevRedirectRef
	}
	return Reference{}
}

func (m *RLineRecap) GetRunnable() []RunnableState {
	if m != nil {
		return m.Runnable
	}
	return nil
}

func (m *RLineRecap) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type RunnableState struct {
	Level     SafetyLevel `protobuf:"varint,20,opt,name=Level,proto3,enum=rms.SafetyLevel" json:"Level"`
	MemoryRef Reference   `protobuf:"bytes,21,opt,name=MemoryRef,proto3" json:"MemoryRef"`
	CodeRef   Reference   `protobuf:"bytes,22,opt,name=CodeRef,proto3" json:"CodeRef"`
	ProofRef  Reference   `protobuf:"bytes,23,opt,name=ProofRef,proto3" json:"ProofRef"`
}

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

var xxx_messageInfo_RunnableState proto.InternalMessageInfo

func (m *RunnableState) GetLevel() SafetyLevel {
	if m != nil {
		return m.Level
	}
	return SafetyLevel_UnknownSafety
}

func (m *RunnableState) GetMemoryRef() Reference {
	if m != nil {
		return m.MemoryRef
	}
	return Reference{}
}

func (m *RunnableState) GetCodeRef() Reference {
	if m != nil {
		return m.CodeRef
	}
	return Reference{}
}

func (m *RunnableState) GetProofRef() Reference {
	if m != nil {
		return m.ProofRef
	}
	return Reference{}
}

type RLineActivate struct {
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	PrevRef    Reference          `protobuf:"bytes,24,opt,name=PrevRef,proto3" json:"PrevRef"`
	RootRef    Reference          `protobuf:"bytes,25,opt,name=RootRef,proto3" json:"RootRef"`
	FieldMap   *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_RLineActivate proto.InternalMessageInfo

func (m *RLineActivate) GetPrevRef() Reference {
	if m != nil {
		return m.PrevRef
	}
	return Reference{}
}

func (m *RLineActivate) GetRootRef() Reference {
	if m != nil {
		return m.RootRef
	}
	return Reference{}
}

func (m *RLineActivate) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type RLineDeactivate struct {
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	PrevRef    Reference          `protobuf:"bytes,24,opt,name=PrevRef,proto3" json:"PrevRef"`
	RootRef    Reference          `protobuf:"bytes,25,opt,name=RootRef,proto3" json:"RootRef"`
	FieldMap   *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_RLineDeactivate proto.InternalMessageInfo

func (m *RLineDeactivate) GetPrevRef() Reference {
	if m != nil {
		return m.PrevRef
	}
	return Reference{}
}

func (m *RLineDeactivate) GetRootRef() Reference {
	if m != nil {
		return m.RootRef
	}
	return Reference{}
}

func (m *RLineDeactivate) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type RLineMemory struct {
	Polymorph  uint32 `protobuf:"varint,16,opt,name=Polymorph,proto3" json:"Polymorph"`
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	PrevRef    Reference          `protobuf:"bytes,24,opt,name=PrevRef,proto3" json:"PrevRef"`
	RootRef    Reference          `protobuf:"bytes,25,opt,name=RootRef,proto3" json:"RootRef"`
	FieldMap   *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_RLineMemory proto.InternalMessageInfo

func (m *RLineMemory) GetPolymorph() uint32 {
	if m != nil {
		return m.Polymorph
	}
	return 0
}

func (m *RLineMemory) GetPrevRef() Reference {
	if m != nil {
		return m.PrevRef
	}
	return Reference{}
}

func (m *RLineMemory) GetRootRef() Reference {
	if m != nil {
		return m.RootRef
	}
	return Reference{}
}

func (m *RLineMemory) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type RLineMemoryExpected struct {
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	FieldMap   *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_RLineMemoryExpected proto.InternalMessageInfo

func (m *RLineMemoryExpected) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type RLineMemoryReuse struct {
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	PrevRef    Reference          `protobuf:"bytes,24,opt,name=PrevRef,proto3" json:"PrevRef"`
	RootRef    Reference          `protobuf:"bytes,25,opt,name=RootRef,proto3" json:"RootRef"`
	FieldMap   *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_RLineMemoryReuse proto.InternalMessageInfo

func (m *RLineMemoryReuse) GetPrevRef() Reference {
	if m != nil {
		return m.PrevRef
	}
	return Reference{}
}

func (m *RLineMemoryReuse) GetRootRef() Reference {
	if m != nil {
		return m.RootRef
	}
	return Reference{}
}

func (m *RLineMemoryReuse) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type RInboundResponse struct {
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	PrevRef    Reference          `protobuf:"bytes,24,opt,name=PrevRef,proto3" json:"PrevRef"`
	RootRef    Reference          `protobuf:"bytes,25,opt,name=RootRef,proto3" json:"RootRef"`
	FieldMap   *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_RInboundResponse proto.InternalMessageInfo

func (m *RInboundResponse) GetPrevRef() Reference {
	if m != nil {
		return m.PrevRef
	}
	return Reference{}
}

func (m *RInboundResponse) GetRootRef() Reference {
	if m != nil {
		return m.RootRef
	}
	return Reference{}
}

func (m *RInboundResponse) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type ROutboundResponse struct {
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	PrevRef    Reference          `protobuf:"bytes,24,opt,name=PrevRef,proto3" json:"PrevRef"`
	RootRef    Reference          `protobuf:"bytes,25,opt,name=RootRef,proto3" json:"RootRef"`
	FieldMap   *insproto.FieldMap `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_ROutboundResponse proto.InternalMessageInfo

func (m *ROutboundResponse) GetPrevRef() Reference {
	if m != nil {
		return m.PrevRef
	}
	return Reference{}
}

func (m *ROutboundResponse) GetRootRef() Reference {
	if m != nil {
		return m.RootRef
	}
	return Reference{}
}

func (m *ROutboundResponse) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

type ROutboundRequest struct {
	Polymorph  uint32 `protobuf:"varint,16,opt,name=Polymorph,proto3" json:"Polymorph"`
	RecordBody `protobuf:"bytes,19,opt,name=RecordBody,proto3,embedded=RecordBody" json:"RecordBody"`
	PrevRef    Reference `protobuf:"bytes,24,opt,name=PrevRef,proto3" json:"PrevRef"`
	RootRef    Reference `protobuf:"bytes,25,opt,name=RootRef,proto3" json:"RootRef"`
	// Add custom fields here
	CallType            CallType            `protobuf:"varint,40,opt,name=CallType,proto3,enum=rms.CallType" json:"CallType"`
	CallFlags           CallFlags           `protobuf:"varint,41,opt,name=CallFlags,proto3,casttype=CallFlags" json:"CallFlags"`
	CallAsOf            PulseNumber         `protobuf:"varint,42,opt,name=CallAsOf,proto3,casttype=PulseNumber" json:"CallAsOf"`
	Caller              Reference           `protobuf:"bytes,43,opt,name=Caller,proto3" json:"Caller"`
	Callee              Reference           `protobuf:"bytes,44,opt,name=Callee,proto3" json:"Callee"`
	CallSiteDeclaration Reference           `protobuf:"bytes,45,opt,name=CallSiteDeclaration,proto3" json:"CallSiteDeclaration"`
	CallSiteMethod      string              `protobuf:"bytes,46,opt,name=CallSiteMethod,proto3" json:"CallSiteMethod"`
	CallSequence        uint32              `protobuf:"varint,47,opt,name=CallSequence,proto3" json:"CallSequence"`
	CallReason          Reference           `protobuf:"bytes,48,opt,name=CallReason,proto3" json:"CallReason"`
	RootTX              Reference           `protobuf:"bytes,49,opt,name=RootTX,proto3" json:"RootTX"`
	CallTX              Reference           `protobuf:"bytes,50,opt,name=CallTX,proto3" json:"CallTX"`
	ExpenseCenter       Reference           `protobuf:"bytes,51,opt,name=ExpenseCenter,proto3" json:"ExpenseCenter"`
	ResourceCenter      Reference           `protobuf:"bytes,52,opt,name=ResourceCenter,proto3" json:"ResourceCenter"`
	DelegationSpec      CallDelegationToken `protobuf:"bytes,54,opt,name=DelegationSpec,proto3" json:"DelegationSpec"`
	TXExpiry            PulseNumber         `protobuf:"varint,62,opt,name=TXExpiry,proto3,casttype=PulseNumber" json:"TXExpiry"`
	SecurityContext     Binary              `protobuf:"bytes,63,opt,name=SecurityContext,proto3" json:"SecurityContext"`
	TXContext           Binary              `protobuf:"bytes,64,opt,name=TXContext,proto3" json:"TXContext"`
	Arguments           Binary              `protobuf:"bytes,65,opt,name=Arguments,proto3" json:"Arguments"`
	FieldMap            *insproto.FieldMap  `protobuf:"bytes,19999,opt,name=FieldMap,proto3" json:"FieldMap,omitempty"`
}

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

var xxx_messageInfo_ROutboundRequest proto.InternalMessageInfo

func (m *ROutboundRequest) GetPolymorph() uint32 {
	if m != nil {
		return m.Polymorph
	}
	return 0
}

func (m *ROutboundRequest) GetPrevRef() Reference {
	if m != nil {
		return m.PrevRef
	}
	return Reference{}
}

func (m *ROutboundRequest) GetRootRef() Reference {
	if m != nil {
		return m.RootRef
	}
	return Reference{}
}

func (m *ROutboundRequest) GetCallType() CallType {
	if m != nil {
		return m.CallType
	}
	return CallTypeInvalid
}

func (m *ROutboundRequest) GetCallFlags() CallFlags {
	if m != nil {
		return m.CallFlags
	}
	return 0
}

func (m *ROutboundRequest) GetCallAsOf() PulseNumber {
	if m != nil {
		return m.CallAsOf
	}
	return 0
}

func (m *ROutboundRequest) GetCaller() Reference {
	if m != nil {
		return m.Caller
	}
	return Reference{}
}

func (m *ROutboundRequest) GetCallee() Reference {
	if m != nil {
		return m.Callee
	}
	return Reference{}
}

func (m *ROutboundRequest) GetCallSiteDeclaration() Reference {
	if m != nil {
		return m.CallSiteDeclaration
	}
	return Reference{}
}

func (m *ROutboundRequest) GetCallSiteMethod() string {
	if m != nil {
		return m.CallSiteMethod
	}
	return ""
}

func (m *ROutboundRequest) GetCallSequence() uint32 {
	if m != nil {
		return m.CallSequence
	}
	return 0
}

func (m *ROutboundRequest) GetCallReason() Reference {
	if m != nil {
		return m.CallReason
	}
	return Reference{}
}

func (m *ROutboundRequest) GetRootTX() Reference {
	if m != nil {
		return m.RootTX
	}
	return Reference{}
}

func (m *ROutboundRequest) GetCallTX() Reference {
	if m != nil {
		return m.CallTX
	}
	return Reference{}
}

func (m *ROutboundRequest) GetExpenseCenter() Reference {
	if m != nil {
		return m.ExpenseCenter
	}
	return Reference{}
}

func (m *ROutboundRequest) GetResourceCenter() Reference {
	if m != nil {
		return m.ResourceCenter
	}
	return Reference{}
}

func (m *ROutboundRequest) GetDelegationSpec() CallDelegationToken {
	if m != nil {
		return m.DelegationSpec
	}
	return CallDelegationToken{}
}

func (m *ROutboundRequest) GetTXExpiry() PulseNumber {
	if m != nil {
		return m.TXExpiry
	}
	return 0
}

func (m *ROutboundRequest) GetSecurityContext() Binary {
	if m != nil {
		return m.SecurityContext
	}
	return Binary{}
}

func (m *ROutboundRequest) GetTXContext() Binary {
	if m != nil {
		return m.TXContext
	}
	return Binary{}
}

func (m *ROutboundRequest) GetArguments() Binary {
	if m != nil {
		return m.Arguments
	}
	return Binary{}
}

func (m *ROutboundRequest) GetFieldMap() *insproto.FieldMap {
	if m != nil {
		return m.FieldMap
	}
	return nil
}

func init() {
	proto.RegisterEnum("rms.FilamentState", FilamentState_name, FilamentState_value)
	proto.RegisterEnum("rms.SafetyLevel", SafetyLevel_name, SafetyLevel_value)
	proto.RegisterType((*RecordExample)(nil), "rms.RecordExample")
	proto.RegisterType((*RLineRecap)(nil), "rms.RLineRecap")
	proto.RegisterType((*RunnableState)(nil), "rms.RunnableState")
	proto.RegisterType((*RLineActivate)(nil), "rms.RLineActivate")
	proto.RegisterType((*RLineDeactivate)(nil), "rms.RLineDeactivate")
	proto.RegisterType((*RLineMemory)(nil), "rms.RLineMemory")
	proto.RegisterType((*RLineMemoryExpected)(nil), "rms.RLineMemoryExpected")
	proto.RegisterType((*RLineMemoryReuse)(nil), "rms.RLineMemoryReuse")
	proto.RegisterType((*RInboundResponse)(nil), "rms.RInboundResponse")
	proto.RegisterType((*ROutboundResponse)(nil), "rms.ROutboundResponse")
	proto.RegisterType((*ROutboundRequest)(nil), "rms.ROutboundRequest")
}

func init() { proto.RegisterFile("proto_records.proto", fileDescriptor_f41a5838de60d5c2) }

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

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

	that1, ok := that.(*RecordExample)
	if !ok {
		that2, ok := that.(RecordExample)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Polymorph != that1.Polymorph {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.Str.Equal(&that1.Str) {
		return false
	}
	if !this.Ref1.Equal(&that1.Ref1) {
		return false
	}
	if this.AsOf != that1.AsOf {
		return false
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (this *RLineRecap) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RLineRecap)
	if !ok {
		that2, ok := that.(RLineRecap)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.PrevRef.Equal(&that1.PrevRef) {
		return false
	}
	if !this.RootRef.Equal(&that1.RootRef) {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if this.ContinuedFrom != that1.ContinuedFrom {
		return false
	}
	if this.PrevType != that1.PrevType {
		return false
	}
	if this.RedirectToType != that1.RedirectToType {
		return false
	}
	if !this.PrevRedirectRef.Equal(&that1.PrevRedirectRef) {
		return false
	}
	if len(this.Runnable) != len(that1.Runnable) {
		return false
	}
	for i := range this.Runnable {
		if !this.Runnable[i].Equal(&that1.Runnable[i]) {
			return false
		}
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (this *RunnableState) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RunnableState)
	if !ok {
		that2, ok := that.(RunnableState)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Level != that1.Level {
		return false
	}
	if !this.MemoryRef.Equal(&that1.MemoryRef) {
		return false
	}
	if !this.CodeRef.Equal(&that1.CodeRef) {
		return false
	}
	if !this.ProofRef.Equal(&that1.ProofRef) {
		return false
	}
	return true
}
func (this *RLineActivate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RLineActivate)
	if !ok {
		that2, ok := that.(RLineActivate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.PrevRef.Equal(&that1.PrevRef) {
		return false
	}
	if !this.RootRef.Equal(&that1.RootRef) {
		return false
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (this *RLineDeactivate) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RLineDeactivate)
	if !ok {
		that2, ok := that.(RLineDeactivate)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.PrevRef.Equal(&that1.PrevRef) {
		return false
	}
	if !this.RootRef.Equal(&that1.RootRef) {
		return false
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (this *RLineMemory) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RLineMemory)
	if !ok {
		that2, ok := that.(RLineMemory)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Polymorph != that1.Polymorph {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.PrevRef.Equal(&that1.PrevRef) {
		return false
	}
	if !this.RootRef.Equal(&that1.RootRef) {
		return false
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (this *RLineMemoryExpected) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

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

	that1, ok := that.(*RLineMemoryReuse)
	if !ok {
		that2, ok := that.(RLineMemoryReuse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.PrevRef.Equal(&that1.PrevRef) {
		return false
	}
	if !this.RootRef.Equal(&that1.RootRef) {
		return false
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (this *RInboundResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RInboundResponse)
	if !ok {
		that2, ok := that.(RInboundResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.PrevRef.Equal(&that1.PrevRef) {
		return false
	}
	if !this.RootRef.Equal(&that1.RootRef) {
		return false
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (this *ROutboundResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ROutboundResponse)
	if !ok {
		that2, ok := that.(ROutboundResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.PrevRef.Equal(&that1.PrevRef) {
		return false
	}
	if !this.RootRef.Equal(&that1.RootRef) {
		return false
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (this *ROutboundRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ROutboundRequest)
	if !ok {
		that2, ok := that.(ROutboundRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Polymorph != that1.Polymorph {
		return false
	}
	if !this.RecordBody.Equal(&that1.RecordBody) {
		return false
	}
	if !this.PrevRef.Equal(&that1.PrevRef) {
		return false
	}
	if !this.RootRef.Equal(&that1.RootRef) {
		return false
	}
	if this.CallType != that1.CallType {
		return false
	}
	if this.CallFlags != that1.CallFlags {
		return false
	}
	if this.CallAsOf != that1.CallAsOf {
		return false
	}
	if !this.Caller.Equal(&that1.Caller) {
		return false
	}
	if !this.Callee.Equal(&that1.Callee) {
		return false
	}
	if !this.CallSiteDeclaration.Equal(&that1.CallSiteDeclaration) {
		return false
	}
	if this.CallSiteMethod != that1.CallSiteMethod {
		return false
	}
	if this.CallSequence != that1.CallSequence {
		return false
	}
	if !this.CallReason.Equal(&that1.CallReason) {
		return false
	}
	if !this.RootTX.Equal(&that1.RootTX) {
		return false
	}
	if !this.CallTX.Equal(&that1.CallTX) {
		return false
	}
	if !this.ExpenseCenter.Equal(&that1.ExpenseCenter) {
		return false
	}
	if !this.ResourceCenter.Equal(&that1.ResourceCenter) {
		return false
	}
	if !this.DelegationSpec.Equal(&that1.DelegationSpec) {
		return false
	}
	if this.TXExpiry != that1.TXExpiry {
		return false
	}
	if !this.SecurityContext.Equal(&that1.SecurityContext) {
		return false
	}
	if !this.TXContext.Equal(&that1.TXContext) {
		return false
	}
	if !this.Arguments.Equal(&that1.Arguments) {
		return false
	}
	if !this.FieldMap.Equal(that1.FieldMap) {
		return false
	}
	return true
}
func (m *RecordExample) Visit(ctx RecordVisitor) error {
	if err := ctx.RecReference(m, 41, &m.Ref1); err != nil {
		return err
	}
	return ctx.Record(m, 999999999)
}

const TypeRecordExamplePolymorphID = 999999999

func (*RecordExample) GetDefaultPolymorphID() uint64 {
	return 999999999
}

func (m *RecordExample) 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 *RecordExample) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RecordExample) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	if m.AsOf != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.AsOf))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd0
	}
	{
		size, err := m.Ref1.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.Str.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if i < len(dAtA) {
		id := uint64(m.Polymorph)
		if id == 0 {
			id = 999999999
		}
		i = encodeVarintProtoRecords(dAtA, i, uint64(id))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *RecordExample) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *RLineRecap) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 19)
}

const TypeRLineRecapPolymorphID = 19

func (*RLineRecap) GetDefaultPolymorphID() uint64 {
	return 19
}

func (m *RLineRecap) 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 *RLineRecap) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RLineRecap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	if len(m.Runnable) > 0 {
		for iNdEx := len(m.Runnable) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Runnable[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x92
		}
	}
	{
		size, err := m.PrevRedirectRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xea
		}
	}
	if m.RedirectToType != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.RedirectToType))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xe0
	}
	if m.PrevType != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.PrevType))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd8
	}
	if m.ContinuedFrom != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.ContinuedFrom))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc8
	}
	if m.State != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc0
	}
	{
		size, err := m.RootRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.PrevRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	i = encodeVarintProtoRecords(dAtA, i, uint64(19))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *RLineRecap) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *RunnableState) 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 *RunnableState) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RunnableState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	{
		size, err := m.ProofRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xba
		}
	}
	{
		size, err := m.CodeRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xb2
		}
	}
	{
		size, err := m.MemoryRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xaa
		}
	}
	if m.Level != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.Level))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if i < len(dAtA) {
		i = encodeVarintProtoRecords(dAtA, i, uint64(0))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	return len(dAtA) - i, nil
}

func (m *RLineActivate) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 20)
}

const TypeRLineActivatePolymorphID = 20

func (*RLineActivate) GetDefaultPolymorphID() uint64 {
	return 20
}

func (m *RLineActivate) 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 *RLineActivate) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RLineActivate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	{
		size, err := m.RootRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.PrevRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	i = encodeVarintProtoRecords(dAtA, i, uint64(20))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *RLineActivate) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *RLineDeactivate) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 21)
}

const TypeRLineDeactivatePolymorphID = 21

func (*RLineDeactivate) GetDefaultPolymorphID() uint64 {
	return 21
}

func (m *RLineDeactivate) 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 *RLineDeactivate) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RLineDeactivate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	{
		size, err := m.RootRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.PrevRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	i = encodeVarintProtoRecords(dAtA, i, uint64(21))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *RLineDeactivate) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *RLineMemory) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 22)
}

const TypeRLineMemoryPolymorphID = 22

func (*RLineMemory) GetDefaultPolymorphID() uint64 {
	return 22
}

func (m *RLineMemory) 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 *RLineMemory) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RLineMemory) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	{
		size, err := m.RootRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.PrevRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if i < len(dAtA) {
		id := uint64(m.Polymorph)
		if id == 0 {
			id = 22
		}
		i = encodeVarintProtoRecords(dAtA, i, uint64(id))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *RLineMemory) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *RLineMemoryExpected) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 25)
}

const TypeRLineMemoryExpectedPolymorphID = 25

func (*RLineMemoryExpected) GetDefaultPolymorphID() uint64 {
	return 25
}

func (m *RLineMemoryExpected) 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 *RLineMemoryExpected) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RLineMemoryExpected) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	i = encodeVarintProtoRecords(dAtA, i, uint64(25))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *RLineMemoryExpected) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *RLineMemoryReuse) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 26)
}

const TypeRLineMemoryReusePolymorphID = 26

func (*RLineMemoryReuse) GetDefaultPolymorphID() uint64 {
	return 26
}

func (m *RLineMemoryReuse) 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 *RLineMemoryReuse) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RLineMemoryReuse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	{
		size, err := m.RootRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.PrevRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	i = encodeVarintProtoRecords(dAtA, i, uint64(26))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *RLineMemoryReuse) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *RInboundResponse) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 27)
}

const TypeRInboundResponsePolymorphID = 27

func (*RInboundResponse) GetDefaultPolymorphID() uint64 {
	return 27
}

func (m *RInboundResponse) 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 *RInboundResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RInboundResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	{
		size, err := m.RootRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.PrevRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	i = encodeVarintProtoRecords(dAtA, i, uint64(27))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *RInboundResponse) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *ROutboundResponse) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 28)
}

const TypeROutboundResponsePolymorphID = 28

func (*ROutboundResponse) GetDefaultPolymorphID() uint64 {
	return 28
}

func (m *ROutboundResponse) 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 *ROutboundResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ROutboundResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	{
		size, err := m.RootRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.PrevRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	i = encodeVarintProtoRecords(dAtA, i, uint64(28))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x80
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *ROutboundResponse) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

func (m *ROutboundRequest) Visit(ctx RecordVisitor) error {
	return ctx.Record(m, 29)
}

const TypeROutboundRequestPolymorphID = 29

func (*ROutboundRequest) GetDefaultPolymorphID() uint64 {
	return 29
}

func (m *ROutboundRequest) 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 *ROutboundRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.ProtoSize()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ROutboundRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l, fieldEnd int
	_, _ = l, fieldEnd
	m.FieldMap.UnsetMap()
	{
		size, err := m.Arguments.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0x8a
		}
	}
	{
		size, err := m.TXContext.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x4
			i--
			dAtA[i] = 0x82
		}
	}
	{
		size, err := m.SecurityContext.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xfa
		}
	}
	if m.TXExpiry != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.TXExpiry))
		i--
		dAtA[i] = 0x3
		i--
		dAtA[i] = 0xf0
	}
	{
		size, err := m.DelegationSpec.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xb2
		}
	}
	{
		size, err := m.ResourceCenter.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0xa2
		}
	}
	{
		size, err := m.ExpenseCenter.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x9a
		}
	}
	{
		size, err := m.CallTX.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x92
		}
	}
	{
		size, err := m.RootTX.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x8a
		}
	}
	{
		size, err := m.CallReason.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x3
			i--
			dAtA[i] = 0x82
		}
	}
	if m.CallSequence != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.CallSequence))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xf8
	}
	if len(m.CallSiteMethod) > 0 {
		i -= len(m.CallSiteMethod)
		copy(dAtA[i:], m.CallSiteMethod)
		i = encodeVarintProtoRecords(dAtA, i, uint64(len(m.CallSiteMethod)))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xf2
	}
	{
		size, err := m.CallSiteDeclaration.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xea
		}
	}
	{
		size, err := m.Callee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xe2
		}
	}
	{
		size, err := m.Caller.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2
			i--
			dAtA[i] = 0xda
		}
	}
	if m.CallAsOf != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.CallAsOf))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xd0
	}
	if m.CallFlags != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.CallFlags))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc8
	}
	if m.CallType != 0 {
		i = encodeVarintProtoRecords(dAtA, i, uint64(m.CallType))
		i--
		dAtA[i] = 0x2
		i--
		dAtA[i] = 0xc0
	}
	{
		size, err := m.RootRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	{
		size, err := m.PrevRef.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xc2
		}
	}
	{
		size, err := m.RecordBody.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		if size > 0 {
			i -= size
			i = encodeVarintProtoRecords(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x9a
		}
	}
	if i < len(dAtA) {
		id := uint64(m.Polymorph)
		if id == 0 {
			id = 29
		}
		i = encodeVarintProtoRecords(dAtA, i, uint64(id))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x80
	}
	m.FieldMap.PutMessage(i, len(dAtA), dAtA)
	return len(dAtA) - i, nil
}

func (m *ROutboundRequest) InitFieldMap(reset bool) *github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap {
	if reset || m.FieldMap == nil {
		m.FieldMap = &github_com_insolar_assured_ledger_ledger_core_insproto.FieldMap{}
	}
	return m.FieldMap
}

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

func init() {
	RegisterRecordType(999999999, "", (*RecordExample)(nil))
	RegisterRecordType(19, "", (*RLineRecap)(nil))
	RegisterRecordType(20, "", (*RLineActivate)(nil))
	RegisterRecordType(21, "", (*RLineDeactivate)(nil))
	RegisterRecordType(22, "", (*RLineMemory)(nil))
	RegisterRecordType(25, "", (*RLineMemoryExpected)(nil))
	RegisterRecordType(26, "", (*RLineMemoryReuse)(nil))
	RegisterRecordType(27, "", (*RInboundResponse)(nil))
	RegisterRecordType(28, "", (*ROutboundResponse)(nil))
	RegisterRecordType(29, "", (*ROutboundRequest)(nil))
}

func (m *RecordExample) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.Str.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.Ref1.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if m.AsOf != 0 {
		n += 2 + sovProtoRecords(uint64(m.AsOf))
	}
	if n > 0 {
		id := uint64(m.Polymorph)
		if id == 0 {
			id = 999999999
		}
		n += 2 + sovProtoRecords(id)
	}
	return n
}

func (m *RLineRecap) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.PrevRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if m.State != 0 {
		n += 2 + sovProtoRecords(uint64(m.State))
	}
	if m.ContinuedFrom != 0 {
		n += 2 + sovProtoRecords(uint64(m.ContinuedFrom))
	}
	if m.PrevType != 0 {
		n += 2 + sovProtoRecords(uint64(m.PrevType))
	}
	if m.RedirectToType != 0 {
		n += 2 + sovProtoRecords(uint64(m.RedirectToType))
	}
	if l = m.PrevRedirectRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if len(m.Runnable) > 0 {
		for _, e := range m.Runnable {
			l = e.ProtoSize()
			n += 2 + l + sovProtoRecords(uint64(l))
		}
	}
	n += 2 + sovProtoRecords(19)
	return n
}

func (m *RunnableState) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Level != 0 {
		n += 2 + sovProtoRecords(uint64(m.Level))
	}
	if l = m.MemoryRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.CodeRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.ProofRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if n > 0 {
		n += 2 + sovProtoRecords(0)
	}
	return n
}

func (m *RLineActivate) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.PrevRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	n += 2 + sovProtoRecords(20)
	return n
}

func (m *RLineDeactivate) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.PrevRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	n += 2 + sovProtoRecords(21)
	return n
}

func (m *RLineMemory) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.PrevRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if n > 0 {
		id := uint64(m.Polymorph)
		if id == 0 {
			id = 22
		}
		n += 2 + sovProtoRecords(id)
	}
	return n
}

func (m *RLineMemoryExpected) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	n += 2 + sovProtoRecords(25)
	return n
}

func (m *RLineMemoryReuse) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.PrevRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	n += 2 + sovProtoRecords(26)
	return n
}

func (m *RInboundResponse) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.PrevRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	n += 2 + sovProtoRecords(27)
	return n
}

func (m *ROutboundResponse) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.PrevRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	n += 2 + sovProtoRecords(28)
	return n
}

func (m *ROutboundRequest) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if l = m.RecordBody.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.PrevRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootRef.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if m.CallType != 0 {
		n += 2 + sovProtoRecords(uint64(m.CallType))
	}
	if m.CallFlags != 0 {
		n += 2 + sovProtoRecords(uint64(m.CallFlags))
	}
	if m.CallAsOf != 0 {
		n += 2 + sovProtoRecords(uint64(m.CallAsOf))
	}
	if l = m.Caller.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.Callee.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.CallSiteDeclaration.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	l = len(m.CallSiteMethod)
	if l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if m.CallSequence != 0 {
		n += 2 + sovProtoRecords(uint64(m.CallSequence))
	}
	if l = m.CallReason.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.RootTX.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.CallTX.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.ExpenseCenter.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.ResourceCenter.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.DelegationSpec.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if m.TXExpiry != 0 {
		n += 2 + sovProtoRecords(uint64(m.TXExpiry))
	}
	if l = m.SecurityContext.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.TXContext.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if l = m.Arguments.ProtoSize(); l > 0 {
		n += 2 + l + sovProtoRecords(uint64(l))
	}
	if n > 0 {
		id := uint64(m.Polymorph)
		if id == 0 {
			id = 29
		}
		n += 2 + sovProtoRecords(id)
	}
	return n
}

func sovProtoRecords(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozProtoRecords(x uint64) (n int) {
	return sovProtoRecords(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RecordExample) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RecordExample) 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 ErrIntOverflowProtoRecords
				}
				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: RecordExample: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RecordExample: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 16:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field Polymorph", wireType)
				}
				m.Polymorph = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.Polymorph |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 40:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Str", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.Str.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 41:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Ref1", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.Ref1.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 42:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field AsOf", wireType)
				}
				m.AsOf = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.AsOf |= PulseNumber(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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *RLineRecap) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RLineRecap) 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 ErrIntOverflowProtoRecords
				}
				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: RLineRecap: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RLineRecap: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 24:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 40:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
				}
				m.State = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.State |= FilamentState(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 41:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field ContinuedFrom", wireType)
				}
				m.ContinuedFrom = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.ContinuedFrom |= PulseNumber(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 43:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevType", wireType)
				}
				m.PrevType = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.PrevType |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 44:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field RedirectToType", wireType)
				}
				m.RedirectToType = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.RedirectToType |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 45:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRedirectRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRedirectRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 50:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Runnable", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				m.Runnable = append(m.Runnable, RunnableState{})
				if err := m.Runnable[len(m.Runnable)-1].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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *RunnableState) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RunnableState) 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 ErrIntOverflowProtoRecords
				}
				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: RunnableState: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RunnableState: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			switch fieldNum {
			case 20:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
				}
				m.Level = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.Level |= SafetyLevel(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 21:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field MemoryRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.MemoryRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 22:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field CodeRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.CodeRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 23:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field ProofRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.ProofRef.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				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 *RLineActivate) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RLineActivate) 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 ErrIntOverflowProtoRecords
				}
				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: RLineActivate: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RLineActivate: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 24:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootRef.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *RLineDeactivate) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RLineDeactivate) 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 ErrIntOverflowProtoRecords
				}
				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: RLineDeactivate: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RLineDeactivate: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 24:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootRef.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *RLineMemory) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RLineMemory) 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 ErrIntOverflowProtoRecords
				}
				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: RLineMemory: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RLineMemory: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 16:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field Polymorph", wireType)
				}
				m.Polymorph = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.Polymorph |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 24:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootRef.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *RLineMemoryExpected) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RLineMemoryExpected) 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 ErrIntOverflowProtoRecords
				}
				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: RLineMemoryExpected: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RLineMemoryExpected: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *RLineMemoryReuse) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RLineMemoryReuse) 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 ErrIntOverflowProtoRecords
				}
				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: RLineMemoryReuse: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RLineMemoryReuse: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 24:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootRef.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *RInboundResponse) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *RInboundResponse) 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 ErrIntOverflowProtoRecords
				}
				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: RInboundResponse: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: RInboundResponse: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 24:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootRef.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *ROutboundResponse) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *ROutboundResponse) 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 ErrIntOverflowProtoRecords
				}
				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: ROutboundResponse: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: ROutboundResponse: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 24:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootRef.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func (m *ROutboundRequest) Unmarshal(dAtA []byte) error {
	_, err := m.UnmarshalWithUnknownCallback(dAtA, skipProtoRecords)
	return err
}
func (m *ROutboundRequest) 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 ErrIntOverflowProtoRecords
				}
				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: ROutboundRequest: wiretype end group for non-group")
			}
			if fieldNum <= 0 {
				return fmt.Errorf("proto: ROutboundRequest: illegal tag %d (wire type %d)", fieldNum, wire)
			}
			m.FieldMap.UnsetMap()
			switch fieldNum {
			case 16:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field Polymorph", wireType)
				}
				m.Polymorph = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.Polymorph |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 19:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RecordBody", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RecordBody.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 24:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field PrevRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.PrevRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 25:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootRef", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootRef.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 40:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field CallType", wireType)
				}
				m.CallType = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.CallType |= CallType(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 41:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field CallFlags", wireType)
				}
				m.CallFlags = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.CallFlags |= CallFlags(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 42:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field CallAsOf", wireType)
				}
				m.CallAsOf = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.CallAsOf |= PulseNumber(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 43:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Caller", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.Caller.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 44:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Callee", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.Callee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 45:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field CallSiteDeclaration", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.CallSiteDeclaration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 46:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field CallSiteMethod", wireType)
				}
				var stringLen uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					stringLen |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				intStringLen := int(stringLen)
				if intStringLen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + intStringLen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				m.CallSiteMethod = string(dAtA[iNdEx:postIndex])
				iNdEx = postIndex
			case 47:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field CallSequence", wireType)
				}
				m.CallSequence = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.CallSequence |= uint32(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 48:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field CallReason", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.CallReason.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 49:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field RootTX", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.RootTX.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 50:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field CallTX", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.CallTX.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 51:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field ExpenseCenter", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.ExpenseCenter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 52:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field ResourceCenter", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.ResourceCenter.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 54:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field DelegationSpec", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.DelegationSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 62:
				if wireType != 0 {
					return fmt.Errorf("proto: wrong wireType = %d for field TXExpiry", wireType)
				}
				m.TXExpiry = 0
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					m.TXExpiry |= PulseNumber(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
			case 63:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field SecurityContext", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.SecurityContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 64:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field TXContext", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.TXContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
					return err
				}
				iNdEx = postIndex
			case 65:
				if wireType != 2 {
					return fmt.Errorf("proto: wrong wireType = %d for field Arguments", wireType)
				}
				var msglen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowProtoRecords
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					msglen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if msglen < 0 {
					return ErrInvalidLengthProtoRecords
				}
				postIndex := iNdEx + msglen
				if postIndex < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				if err := m.Arguments.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 = skipProtoRecords(dAtA[iNdEx:]); err != nil {
						return err
					}
				}
				if (iNdEx + skippy) < 0 {
					return ErrInvalidLengthProtoRecords
				}
				if (iNdEx + skippy) > l {
					return io.ErrUnexpectedEOF
				}
				iNdEx += skippy
			}
			return nil
		}()
		if err != nil {
			return preIndex, err
		}
	}

	if iNdEx > l {
		return iNdEx, io.ErrUnexpectedEOF
	}
	m.FieldMap.PutMessage(0, iNdEx, dAtA)
	return iNdEx, nil
}
func skipProtoRecords(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, ErrIntOverflowProtoRecords
			}
			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, ErrIntOverflowProtoRecords
				}
				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, ErrIntOverflowProtoRecords
				}
				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, ErrInvalidLengthProtoRecords
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupProtoRecords
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthProtoRecords
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthProtoRecords        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtoRecords          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupProtoRecords = fmt.Errorf("proto: unexpected end of group")
	ErrExpectedBinaryMarkerProtoRecords = fmt.Errorf("proto: binary marker was expected")
)