recorded_op.pb.go

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

package recoverylog

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"

import github_com_LiveRamp_gazette_v2_pkg_protocol "github.com/LiveRamp/gazette/v2/pkg/protocol"

import encoding_binary "encoding/binary"

import io "io"

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

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

// RecordedOp records states changes occuring within a local file-system.
// Next tag: 11.
type RecordedOp struct {
	// Monotonically-increasing sequence number of this operation.
	SeqNo int64 `protobuf:"varint,1,opt,name=seq_no,json=seqNo,proto3" json:"seq_no,omitempty"`
	// Previous FSM checksum to which this operation should be applied (eg, the
	// expected checksum arrived at after applying the previous operation.
	Checksum uint32 `protobuf:"fixed32,2,opt,name=checksum,proto3" json:"checksum,omitempty"`
	// Author is the unique ID of the Recorder which wrote this RecordedOp.
	// Each Recorder randomly generates an Author ID at startup, and thereafter
	// applies it to all operations it records.
	Author Author `protobuf:"fixed32,3,opt,name=author,proto3,casttype=Author" json:"author,omitempty"`
	// First and last byte offset (exclusive) of this RecordedOp. These are meta-
	// fields which are not populated in the recorded log (as Recorders cannot
	// know at what offsets their writes will land in the log). Instead, Players
	// attach offsets as they deserialize RecordedOps from the committed log.
	FirstOffset int64              `protobuf:"varint,9,opt,name=first_offset,json=firstOffset,proto3" json:"first_offset,omitempty"`
	LastOffset  int64              `protobuf:"varint,10,opt,name=last_offset,json=lastOffset,proto3" json:"last_offset,omitempty"`
	Create      *RecordedOp_Create `protobuf:"bytes,4,opt,name=create" json:"create,omitempty"`
	Link        *RecordedOp_Link   `protobuf:"bytes,5,opt,name=link" json:"link,omitempty"`
	Unlink      *RecordedOp_Link   `protobuf:"bytes,6,opt,name=unlink" json:"unlink,omitempty"`
	Write       *RecordedOp_Write  `protobuf:"bytes,7,opt,name=write" json:"write,omitempty"`
	// Property indicates a property file has been created or updated.
	Property *Property `protobuf:"bytes,8,opt,name=property" json:"property,omitempty"`
}

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

var xxx_messageInfo_RecordedOp proto.InternalMessageInfo

// Create a new "File Node" (Fnode), initially linked to |path|. Fnodes play
// a similar role to Posix inodes: they identify a specific file object while
// being invariant to (and spanning across) its current or future path links.
// The assigned Fnode ID is the |seq_no| of this RecordedOp.
type RecordedOp_Create struct {
	// Filesystem path of this file, relative to the common base directory.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
}

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

var xxx_messageInfo_RecordedOp_Create proto.InternalMessageInfo

// Link or unlink an Fnode to a filesystem path.
type RecordedOp_Link struct {
	// Fnode being linked or unlinked.
	Fnode Fnode `protobuf:"varint,1,opt,name=fnode,proto3,casttype=Fnode" json:"fnode,omitempty"`
	// Filesystem path being un/linked, relative to the common base directory.
	Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
}

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

var xxx_messageInfo_RecordedOp_Link proto.InternalMessageInfo

// Write indicates |length| bytes should be written at |offset| to |fnode|.
// In a serialization stream, we expect |length| raw bytes of content to
// immediately follow this operation.
type RecordedOp_Write struct {
	// Fnode being written to.
	Fnode Fnode `protobuf:"varint,1,opt,name=fnode,proto3,casttype=Fnode" json:"fnode,omitempty"`
	// Byte-offset within the file to which this write is applied.
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Length of the write.
	Length int64 `protobuf:"varint,3,opt,name=length,proto3" json:"length,omitempty"`
}

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

var xxx_messageInfo_RecordedOp_Write proto.InternalMessageInfo

// Property is a small file which rarely changes, and is thus managed
// outside of regular Fnode tracking. See FSM.Properties.
type Property struct {
	// Filesystem path of this property, relative to the common base directory.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// Complete file content of this property.
	Content string `protobuf:"bytes,2,opt,name=content,proto3" json:"content,omitempty"`
}

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

var xxx_messageInfo_Property proto.InternalMessageInfo

// Segment is a contiguous chunk of recovery log written by a single Author.
// Recorders track Segments they have written, for use in providing hints to
// future readers of the log. A key point to understand is that Gazette append
// semantics mean that Recorders *cannot know* exactly what offsets their writes
// are applied to in the log, nor guarantee that their operations are not being
// interleaved with those of other writers. Log Players are aware of these
// limitations, and use Segments to resolve conflicts of possible interpretation
// of the log. Segments produced by a Player are exact, since Players observe all
// recorded operations at their exact offsets.
// Next tag: 7.
type Segment struct {
	// Author which wrote RecordedOps of this Segment.
	Author Author `protobuf:"fixed32,1,opt,name=author,proto3,casttype=Author" json:"author,omitempty"`
	// First (lowest) sequence number of RecordedOps within this Segment.
	FirstSeqNo int64 `protobuf:"varint,2,opt,name=first_seq_no,json=firstSeqNo,proto3" json:"first_seq_no,omitempty"`
	// First byte offset of the Segment, where |first_seq_no| is recorded.
	// If this Segment was produced by a Recorder, this is guaranteed only to be a
	// lower-bound (eg, a Player reading at this offset may encounter irrelevant
	// operations prior to the RecordedOp indicated by the tuple
	// (|author|, |first_seq_no|, |first_checksum|). If a Player produced the Segment,
	// first_offset is exact.
	FirstOffset int64 `protobuf:"varint,3,opt,name=first_offset,json=firstOffset,proto3" json:"first_offset,omitempty"`
	// Checksum of the RecordedOp having |first_seq_no|.
	FirstChecksum uint32 `protobuf:"fixed32,4,opt,name=first_checksum,json=firstChecksum,proto3" json:"first_checksum,omitempty"`
	// Last (highest, inclusive) sequence number of RecordedOps within this Segment.
	LastSeqNo int64 `protobuf:"varint,5,opt,name=last_seq_no,json=lastSeqNo,proto3" json:"last_seq_no,omitempty"`
	// Last offset (exclusive) of the Segment. Zero means the offset is not known
	// (eg, because the Segment was produced by a Recorder).
	LastOffset int64 `protobuf:"varint,6,opt,name=last_offset,json=lastOffset,proto3" json:"last_offset,omitempty"`
}

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

var xxx_messageInfo_Segment proto.InternalMessageInfo

// FnodeSegments captures log Segments containing all RecordedOps of the Fnode.
type FnodeSegments struct {
	// Fnode being hinted.
	Fnode Fnode `protobuf:"varint,1,opt,name=fnode,proto3,casttype=Fnode" json:"fnode,omitempty"`
	// Segments of the Fnode in the log. Currently, FSM tracks only a single
	// Segment per Fnode per Author. A specific implication of this is that Fnodes
	// modified over long periods of time will result in Segments spanning large
	// chunks of the log. For best performance, Fnodes should be opened & written
	// once, and then never be modified again (this is RocksDB's behavior).
	// If supporting this case is desired, FSM will have to be a bit smarter about
	// not extending Segments which gap over significant portions of the log
	// (eg, there's a trade-off to make over size of the hinted manifest, vs
	// savings incurred on playback by being able to skip portions of the log).
	Segments []Segment `protobuf:"bytes,2,rep,name=segments" json:"segments"`
}

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

var xxx_messageInfo_FnodeSegments proto.InternalMessageInfo

// FSMHints represents a manifest of Fnodes which were still live (eg, having
// remaining links) at the time the FSMHints were produced, as well as any
// Properties. It allows a Player of the log to identify minimal Segments which
// must be read to recover all Fnodes, and also contains sufficient metadata for
// a Player to resolve all possible conflicts it could encounter while reading
// the log, to arrive at a consistent view of file state which exactly matches
// that of the Recorder producing the FSMHints.
// Next tag: 4.
type FSMHints struct {
	// Log is the Journal name holding recorded log content.
	Log github_com_LiveRamp_gazette_v2_pkg_protocol.Journal `protobuf:"bytes,1,opt,name=log,proto3,casttype=github.com/LiveRamp/gazette/v2/pkg/protocol.Journal" json:"log,omitempty"`
	// Live Fnodes and their Segments as-of the generation of these FSMHints.
	LiveNodes []FnodeSegments `protobuf:"bytes,2,rep,name=live_nodes,json=liveNodes" json:"live_nodes"`
	// Property files and contents as-of the generation of these FSMHints.
	Properties []Property `protobuf:"bytes,3,rep,name=properties" json:"properties"`
}

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

var xxx_messageInfo_FSMHints proto.InternalMessageInfo

func init() {
	proto.RegisterType((*RecordedOp)(nil), "recoverylog.RecordedOp")
	proto.RegisterType((*RecordedOp_Create)(nil), "recoverylog.RecordedOp.Create")
	proto.RegisterType((*RecordedOp_Link)(nil), "recoverylog.RecordedOp.Link")
	proto.RegisterType((*RecordedOp_Write)(nil), "recoverylog.RecordedOp.Write")
	proto.RegisterType((*Property)(nil), "recoverylog.Property")
	proto.RegisterType((*Segment)(nil), "recoverylog.Segment")
	proto.RegisterType((*FnodeSegments)(nil), "recoverylog.FnodeSegments")
	proto.RegisterType((*FSMHints)(nil), "recoverylog.FSMHints")
}
func (m *RecordedOp) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RecordedOp) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.SeqNo != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.SeqNo))
	}
	if m.Checksum != 0 {
		dAtA[i] = 0x15
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Checksum))
		i += 4
	}
	if m.Author != 0 {
		dAtA[i] = 0x1d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Author))
		i += 4
	}
	if m.Create != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Create.ProtoSize()))
		n1, err := m.Create.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.Link != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Link.ProtoSize()))
		n2, err := m.Link.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Unlink != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Unlink.ProtoSize()))
		n3, err := m.Unlink.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Write != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Write.ProtoSize()))
		n4, err := m.Write.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.Property != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Property.ProtoSize()))
		n5, err := m.Property.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.FirstOffset != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.FirstOffset))
	}
	if m.LastOffset != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.LastOffset))
	}
	return i, nil
}

func (m *RecordedOp_Create) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RecordedOp_Create) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Path) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(len(m.Path)))
		i += copy(dAtA[i:], m.Path)
	}
	return i, nil
}

func (m *RecordedOp_Link) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RecordedOp_Link) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Fnode != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Fnode))
	}
	if len(m.Path) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(len(m.Path)))
		i += copy(dAtA[i:], m.Path)
	}
	return i, nil
}

func (m *RecordedOp_Write) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RecordedOp_Write) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Fnode != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Fnode))
	}
	if m.Offset != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Offset))
	}
	if m.Length != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Length))
	}
	return i, nil
}

func (m *Property) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Property) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Path) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(len(m.Path)))
		i += copy(dAtA[i:], m.Path)
	}
	if len(m.Content) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(len(m.Content)))
		i += copy(dAtA[i:], m.Content)
	}
	return i, nil
}

func (m *Segment) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Segment) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Author != 0 {
		dAtA[i] = 0xd
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Author))
		i += 4
	}
	if m.FirstSeqNo != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.FirstSeqNo))
	}
	if m.FirstOffset != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.FirstOffset))
	}
	if m.FirstChecksum != 0 {
		dAtA[i] = 0x25
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.FirstChecksum))
		i += 4
	}
	if m.LastSeqNo != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.LastSeqNo))
	}
	if m.LastOffset != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.LastOffset))
	}
	return i, nil
}

func (m *FnodeSegments) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FnodeSegments) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Fnode != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(m.Fnode))
	}
	if len(m.Segments) > 0 {
		for _, msg := range m.Segments {
			dAtA[i] = 0x12
			i++
			i = encodeVarintRecordedOp(dAtA, i, uint64(msg.ProtoSize()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *FSMHints) Marshal() (dAtA []byte, err error) {
	size := m.ProtoSize()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FSMHints) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Log) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintRecordedOp(dAtA, i, uint64(len(m.Log)))
		i += copy(dAtA[i:], m.Log)
	}
	if len(m.LiveNodes) > 0 {
		for _, msg := range m.LiveNodes {
			dAtA[i] = 0x12
			i++
			i = encodeVarintRecordedOp(dAtA, i, uint64(msg.ProtoSize()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.Properties) > 0 {
		for _, msg := range m.Properties {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintRecordedOp(dAtA, i, uint64(msg.ProtoSize()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func encodeVarintRecordedOp(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *RecordedOp) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SeqNo != 0 {
		n += 1 + sovRecordedOp(uint64(m.SeqNo))
	}
	if m.Checksum != 0 {
		n += 5
	}
	if m.Author != 0 {
		n += 5
	}
	if m.Create != nil {
		l = m.Create.ProtoSize()
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	if m.Link != nil {
		l = m.Link.ProtoSize()
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	if m.Unlink != nil {
		l = m.Unlink.ProtoSize()
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	if m.Write != nil {
		l = m.Write.ProtoSize()
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	if m.Property != nil {
		l = m.Property.ProtoSize()
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	if m.FirstOffset != 0 {
		n += 1 + sovRecordedOp(uint64(m.FirstOffset))
	}
	if m.LastOffset != 0 {
		n += 1 + sovRecordedOp(uint64(m.LastOffset))
	}
	return n
}

func (m *RecordedOp_Create) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	return n
}

func (m *RecordedOp_Link) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Fnode != 0 {
		n += 1 + sovRecordedOp(uint64(m.Fnode))
	}
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	return n
}

func (m *RecordedOp_Write) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Fnode != 0 {
		n += 1 + sovRecordedOp(uint64(m.Fnode))
	}
	if m.Offset != 0 {
		n += 1 + sovRecordedOp(uint64(m.Offset))
	}
	if m.Length != 0 {
		n += 1 + sovRecordedOp(uint64(m.Length))
	}
	return n
}

func (m *Property) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Path)
	if l > 0 {
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	l = len(m.Content)
	if l > 0 {
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	return n
}

func (m *Segment) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Author != 0 {
		n += 5
	}
	if m.FirstSeqNo != 0 {
		n += 1 + sovRecordedOp(uint64(m.FirstSeqNo))
	}
	if m.FirstOffset != 0 {
		n += 1 + sovRecordedOp(uint64(m.FirstOffset))
	}
	if m.FirstChecksum != 0 {
		n += 5
	}
	if m.LastSeqNo != 0 {
		n += 1 + sovRecordedOp(uint64(m.LastSeqNo))
	}
	if m.LastOffset != 0 {
		n += 1 + sovRecordedOp(uint64(m.LastOffset))
	}
	return n
}

func (m *FnodeSegments) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Fnode != 0 {
		n += 1 + sovRecordedOp(uint64(m.Fnode))
	}
	if len(m.Segments) > 0 {
		for _, e := range m.Segments {
			l = e.ProtoSize()
			n += 1 + l + sovRecordedOp(uint64(l))
		}
	}
	return n
}

func (m *FSMHints) ProtoSize() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Log)
	if l > 0 {
		n += 1 + l + sovRecordedOp(uint64(l))
	}
	if len(m.LiveNodes) > 0 {
		for _, e := range m.LiveNodes {
			l = e.ProtoSize()
			n += 1 + l + sovRecordedOp(uint64(l))
		}
	}
	if len(m.Properties) > 0 {
		for _, e := range m.Properties {
			l = e.ProtoSize()
			n += 1 + l + sovRecordedOp(uint64(l))
		}
	}
	return n
}

func sovRecordedOp(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozRecordedOp(x uint64) (n int) {
	return sovRecordedOp(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *RecordedOp) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRecordedOp
			}
			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: RecordedOp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RecordedOp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SeqNo", wireType)
			}
			m.SeqNo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SeqNo |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Checksum", wireType)
			}
			m.Checksum = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Checksum = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Author", wireType)
			}
			m.Author = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Author = Author(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Create", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Create == nil {
				m.Create = &RecordedOp_Create{}
			}
			if err := m.Create.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Link", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Link == nil {
				m.Link = &RecordedOp_Link{}
			}
			if err := m.Link.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unlink", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Unlink == nil {
				m.Unlink = &RecordedOp_Link{}
			}
			if err := m.Unlink.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Write", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Write == nil {
				m.Write = &RecordedOp_Write{}
			}
			if err := m.Write.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Property", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Property == nil {
				m.Property = &Property{}
			}
			if err := m.Property.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstOffset", wireType)
			}
			m.FirstOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstOffset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastOffset", wireType)
			}
			m.LastOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastOffset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRecordedOp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRecordedOp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecordedOp_Link) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRecordedOp
			}
			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: Link: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Link: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fnode", wireType)
			}
			m.Fnode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fnode |= (Fnode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				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 ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRecordedOp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRecordedOp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RecordedOp_Write) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRecordedOp
			}
			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: Write: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Write: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Fnode", wireType)
			}
			m.Fnode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Fnode |= (Fnode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType)
			}
			m.Length = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Length |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRecordedOp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRecordedOp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Segment) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRecordedOp
			}
			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: Segment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Segment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Author", wireType)
			}
			m.Author = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.Author = Author(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstSeqNo", wireType)
			}
			m.FirstSeqNo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstSeqNo |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstOffset", wireType)
			}
			m.FirstOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstOffset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstChecksum", wireType)
			}
			m.FirstChecksum = 0
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			m.FirstChecksum = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastSeqNo", wireType)
			}
			m.LastSeqNo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastSeqNo |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastOffset", wireType)
			}
			m.LastOffset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastOffset |= (int64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRecordedOp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRecordedOp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FSMHints) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowRecordedOp
			}
			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: FSMHints: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FSMHints: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				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 ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Log = github_com_LiveRamp_gazette_v2_pkg_protocol.Journal(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LiveNodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LiveNodes = append(m.LiveNodes, FnodeSegments{})
			if err := m.LiveNodes[len(m.LiveNodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Properties", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRecordedOp
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRecordedOp
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Properties = append(m.Properties, Property{})
			if err := m.Properties[len(m.Properties)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRecordedOp(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthRecordedOp
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

func init() { proto.RegisterFile("recorded_op.proto", fileDescriptor_recorded_op_1b5934276ddb646a) }

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