github.com/pachyderm/pachyderm@v1.13.4/src/server/worker/pipeline/transform/transform.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: server/worker/pipeline/transform/transform.proto

package transform

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	pfs "github.com/pachyderm/pachyderm/src/client/pfs"
	pps "github.com/pachyderm/pachyderm/src/client/pps"
	common "github.com/pachyderm/pachyderm/src/server/worker/common"
	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

// DatumInputs is the message contained in the object pointed to by the
// DatumData.datums field.
type DatumInputs struct {
	Inputs               []*common.Input `protobuf:"bytes,1,rep,name=inputs,proto3" json:"inputs,omitempty"`
	Index                int64           `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_DatumInputs proto.InternalMessageInfo

func (m *DatumInputs) GetInputs() []*common.Input {
	if m != nil {
		return m.Inputs
	}
	return nil
}

func (m *DatumInputs) GetIndex() int64 {
	if m != nil {
		return m.Index
	}
	return 0
}

type DatumInputsList struct {
	Datums               []*DatumInputs `protobuf:"bytes,1,rep,name=datums,proto3" json:"datums,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_DatumInputsList proto.InternalMessageInfo

func (m *DatumInputsList) GetDatums() []*DatumInputs {
	if m != nil {
		return m.Datums
	}
	return nil
}

// HashtreeObjects is the message contained in the object generated by the
// registry when a job moves from the 'running' state to the 'merging' state. It
// contains references to all generated hashtree chunks from the job, which must
// be merged into the final hashtree.
type HashtreeObjects struct {
	ChunkObjects         []string `protobuf:"bytes,1,rep,name=chunk_objects,json=chunkObjects,proto3" json:"chunk_objects,omitempty"`
	StatsObjects         []string `protobuf:"bytes,2,rep,name=stats_objects,json=statsObjects,proto3" json:"stats_objects,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HashtreeObjects proto.InternalMessageInfo

func (m *HashtreeObjects) GetChunkObjects() []string {
	if m != nil {
		return m.ChunkObjects
	}
	return nil
}

func (m *HashtreeObjects) GetStatsObjects() []string {
	if m != nil {
		return m.StatsObjects
	}
	return nil
}

type RecoveredDatums struct {
	Hashes               []string `protobuf:"bytes,1,rep,name=hashes,proto3" json:"hashes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RecoveredDatums proto.InternalMessageInfo

func (m *RecoveredDatums) GetHashes() []string {
	if m != nil {
		return m.Hashes
	}
	return nil
}

type RecoveredDatumObjects struct {
	Objects              []string `protobuf:"bytes,1,rep,name=objects,proto3" json:"objects,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RecoveredDatumObjects proto.InternalMessageInfo

func (m *RecoveredDatumObjects) GetObjects() []string {
	if m != nil {
		return m.Objects
	}
	return nil
}

type HashtreeInfo struct {
	// Address used for fetching a cached version directly from the worker
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// The subtask ID can be used to fetch the cached hashtree directly from the worker
	SubtaskID string `protobuf:"bytes,2,opt,name=subtask_id,json=subtaskId,proto3" json:"subtask_id,omitempty"`
	// The object can be used to fetch the hashtree from object storage if the
	// worker cannot be reached or does not have it cached.
	Object               string   `protobuf:"bytes,3,opt,name=object,proto3" json:"object,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_HashtreeInfo proto.InternalMessageInfo

func (m *HashtreeInfo) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *HashtreeInfo) GetSubtaskID() string {
	if m != nil {
		return m.SubtaskID
	}
	return ""
}

func (m *HashtreeInfo) GetObject() string {
	if m != nil {
		return m.Object
	}
	return ""
}

type DatumStats struct {
	ProcessStats         *pps.ProcessStats `protobuf:"bytes,1,opt,name=process_stats,json=processStats,proto3" json:"process_stats,omitempty"`
	DatumsProcessed      int64             `protobuf:"varint,2,opt,name=datums_processed,json=datumsProcessed,proto3" json:"datums_processed,omitempty"`
	DatumsSkipped        int64             `protobuf:"varint,3,opt,name=datums_skipped,json=datumsSkipped,proto3" json:"datums_skipped,omitempty"`
	DatumsFailed         int64             `protobuf:"varint,5,opt,name=datums_failed,json=datumsFailed,proto3" json:"datums_failed,omitempty"`
	DatumsRecovered      int64             `protobuf:"varint,6,opt,name=datums_recovered,json=datumsRecovered,proto3" json:"datums_recovered,omitempty"`
	FailedDatumID        string            `protobuf:"bytes,8,opt,name=failed_datum_id,json=failedDatumId,proto3" json:"failed_datum_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_DatumStats proto.InternalMessageInfo

func (m *DatumStats) GetProcessStats() *pps.ProcessStats {
	if m != nil {
		return m.ProcessStats
	}
	return nil
}

func (m *DatumStats) GetDatumsProcessed() int64 {
	if m != nil {
		return m.DatumsProcessed
	}
	return 0
}

func (m *DatumStats) GetDatumsSkipped() int64 {
	if m != nil {
		return m.DatumsSkipped
	}
	return 0
}

func (m *DatumStats) GetDatumsFailed() int64 {
	if m != nil {
		return m.DatumsFailed
	}
	return 0
}

func (m *DatumStats) GetDatumsRecovered() int64 {
	if m != nil {
		return m.DatumsRecovered
	}
	return 0
}

func (m *DatumStats) GetFailedDatumID() string {
	if m != nil {
		return m.FailedDatumID
	}
	return ""
}

type DatumData struct {
	// Inputs
	JobID        string      `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	DatumsObject string      `protobuf:"bytes,8,opt,name=datums_object,json=datumsObject,proto3" json:"datums_object,omitempty"`
	OutputCommit *pfs.Commit `protobuf:"bytes,3,opt,name=output_commit,json=outputCommit,proto3" json:"output_commit,omitempty"`
	// Outputs
	Stats                 *DatumStats   `protobuf:"bytes,4,opt,name=stats,proto3" json:"stats,omitempty"`
	ChunkHashtree         *HashtreeInfo `protobuf:"bytes,5,opt,name=chunk_hashtree,json=chunkHashtree,proto3" json:"chunk_hashtree,omitempty"`
	StatsHashtree         *HashtreeInfo `protobuf:"bytes,6,opt,name=stats_hashtree,json=statsHashtree,proto3" json:"stats_hashtree,omitempty"`
	RecoveredDatumsObject string        `protobuf:"bytes,7,opt,name=recovered_datums_object,json=recoveredDatumsObject,proto3" json:"recovered_datums_object,omitempty"`
	XXX_NoUnkeyedLiteral  struct{}      `json:"-"`
	XXX_unrecognized      []byte        `json:"-"`
	XXX_sizecache         int32         `json:"-"`
}

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

var xxx_messageInfo_DatumData proto.InternalMessageInfo

func (m *DatumData) GetJobID() string {
	if m != nil {
		return m.JobID
	}
	return ""
}

func (m *DatumData) GetDatumsObject() string {
	if m != nil {
		return m.DatumsObject
	}
	return ""
}

func (m *DatumData) GetOutputCommit() *pfs.Commit {
	if m != nil {
		return m.OutputCommit
	}
	return nil
}

func (m *DatumData) GetStats() *DatumStats {
	if m != nil {
		return m.Stats
	}
	return nil
}

func (m *DatumData) GetChunkHashtree() *HashtreeInfo {
	if m != nil {
		return m.ChunkHashtree
	}
	return nil
}

func (m *DatumData) GetStatsHashtree() *HashtreeInfo {
	if m != nil {
		return m.StatsHashtree
	}
	return nil
}

func (m *DatumData) GetRecoveredDatumsObject() string {
	if m != nil {
		return m.RecoveredDatumsObject
	}
	return ""
}

type MergeData struct {
	// Inputs
	JobID     string          `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
	Hashtrees []*HashtreeInfo `protobuf:"bytes,2,rep,name=hashtrees,proto3" json:"hashtrees,omitempty"`
	Parent    *pfs.Object     `protobuf:"bytes,3,opt,name=parent,proto3" json:"parent,omitempty"`
	Shard     int64           `protobuf:"varint,4,opt,name=shard,proto3" json:"shard,omitempty"`
	Stats     bool            `protobuf:"varint,5,opt,name=stats,proto3" json:"stats,omitempty"`
	// Outputs
	Tree                 *pfs.Object `protobuf:"bytes,6,opt,name=tree,proto3" json:"tree,omitempty"`
	TreeSize             uint64      `protobuf:"varint,7,opt,name=tree_size,json=treeSize,proto3" json:"tree_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (m *MergeData) Reset()         { *m = MergeData{} }
func (m *MergeData) String() string { return proto.CompactTextString(m) }
func (*MergeData) ProtoMessage()    {}
func (*MergeData) Descriptor() ([]byte, []int) {
	return fileDescriptor_21583a759eb7fa97, []int{8}
}
func (m *MergeData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MergeData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MergeData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *MergeData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MergeData.Merge(m, src)
}
func (m *MergeData) XXX_Size() int {
	return m.Size()
}
func (m *MergeData) XXX_DiscardUnknown() {
	xxx_messageInfo_MergeData.DiscardUnknown(m)
}

var xxx_messageInfo_MergeData proto.InternalMessageInfo

func (m *MergeData) GetJobID() string {
	if m != nil {
		return m.JobID
	}
	return ""
}

func (m *MergeData) GetHashtrees() []*HashtreeInfo {
	if m != nil {
		return m.Hashtrees
	}
	return nil
}

func (m *MergeData) GetParent() *pfs.Object {
	if m != nil {
		return m.Parent
	}
	return nil
}

func (m *MergeData) GetShard() int64 {
	if m != nil {
		return m.Shard
	}
	return 0
}

func (m *MergeData) GetStats() bool {
	if m != nil {
		return m.Stats
	}
	return false
}

func (m *MergeData) GetTree() *pfs.Object {
	if m != nil {
		return m.Tree
	}
	return nil
}

func (m *MergeData) GetTreeSize() uint64 {
	if m != nil {
		return m.TreeSize
	}
	return 0
}

func init() {
	proto.RegisterType((*DatumInputs)(nil), "pachyderm.worker.pipeline.transform.DatumInputs")
	proto.RegisterType((*DatumInputsList)(nil), "pachyderm.worker.pipeline.transform.DatumInputsList")
	proto.RegisterType((*HashtreeObjects)(nil), "pachyderm.worker.pipeline.transform.HashtreeObjects")
	proto.RegisterType((*RecoveredDatums)(nil), "pachyderm.worker.pipeline.transform.RecoveredDatums")
	proto.RegisterType((*RecoveredDatumObjects)(nil), "pachyderm.worker.pipeline.transform.RecoveredDatumObjects")
	proto.RegisterType((*HashtreeInfo)(nil), "pachyderm.worker.pipeline.transform.HashtreeInfo")
	proto.RegisterType((*DatumStats)(nil), "pachyderm.worker.pipeline.transform.DatumStats")
	proto.RegisterType((*DatumData)(nil), "pachyderm.worker.pipeline.transform.DatumData")
	proto.RegisterType((*MergeData)(nil), "pachyderm.worker.pipeline.transform.MergeData")
}

func init() {
	proto.RegisterFile("server/worker/pipeline/transform/transform.proto", fileDescriptor_21583a759eb7fa97)
}

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

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

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

func (m *DatumInputs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Index != 0 {
		i = encodeVarintTransform(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Inputs) > 0 {
		for iNdEx := len(m.Inputs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Inputs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTransform(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DatumInputsList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Datums) > 0 {
		for iNdEx := len(m.Datums) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Datums[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTransform(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *HashtreeObjects) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.StatsObjects) > 0 {
		for iNdEx := len(m.StatsObjects) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.StatsObjects[iNdEx])
			copy(dAtA[i:], m.StatsObjects[iNdEx])
			i = encodeVarintTransform(dAtA, i, uint64(len(m.StatsObjects[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ChunkObjects) > 0 {
		for iNdEx := len(m.ChunkObjects) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ChunkObjects[iNdEx])
			copy(dAtA[i:], m.ChunkObjects[iNdEx])
			i = encodeVarintTransform(dAtA, i, uint64(len(m.ChunkObjects[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *RecoveredDatums) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Hashes) > 0 {
		for iNdEx := len(m.Hashes) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Hashes[iNdEx])
			copy(dAtA[i:], m.Hashes[iNdEx])
			i = encodeVarintTransform(dAtA, i, uint64(len(m.Hashes[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *RecoveredDatumObjects) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Objects) > 0 {
		for iNdEx := len(m.Objects) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Objects[iNdEx])
			copy(dAtA[i:], m.Objects[iNdEx])
			i = encodeVarintTransform(dAtA, i, uint64(len(m.Objects[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

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

func (m *HashtreeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Object) > 0 {
		i -= len(m.Object)
		copy(dAtA[i:], m.Object)
		i = encodeVarintTransform(dAtA, i, uint64(len(m.Object)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.SubtaskID) > 0 {
		i -= len(m.SubtaskID)
		copy(dAtA[i:], m.SubtaskID)
		i = encodeVarintTransform(dAtA, i, uint64(len(m.SubtaskID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintTransform(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DatumStats) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.FailedDatumID) > 0 {
		i -= len(m.FailedDatumID)
		copy(dAtA[i:], m.FailedDatumID)
		i = encodeVarintTransform(dAtA, i, uint64(len(m.FailedDatumID)))
		i--
		dAtA[i] = 0x42
	}
	if m.DatumsRecovered != 0 {
		i = encodeVarintTransform(dAtA, i, uint64(m.DatumsRecovered))
		i--
		dAtA[i] = 0x30
	}
	if m.DatumsFailed != 0 {
		i = encodeVarintTransform(dAtA, i, uint64(m.DatumsFailed))
		i--
		dAtA[i] = 0x28
	}
	if m.DatumsSkipped != 0 {
		i = encodeVarintTransform(dAtA, i, uint64(m.DatumsSkipped))
		i--
		dAtA[i] = 0x18
	}
	if m.DatumsProcessed != 0 {
		i = encodeVarintTransform(dAtA, i, uint64(m.DatumsProcessed))
		i--
		dAtA[i] = 0x10
	}
	if m.ProcessStats != nil {
		{
			size, err := m.ProcessStats.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransform(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *DatumData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.DatumsObject) > 0 {
		i -= len(m.DatumsObject)
		copy(dAtA[i:], m.DatumsObject)
		i = encodeVarintTransform(dAtA, i, uint64(len(m.DatumsObject)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.RecoveredDatumsObject) > 0 {
		i -= len(m.RecoveredDatumsObject)
		copy(dAtA[i:], m.RecoveredDatumsObject)
		i = encodeVarintTransform(dAtA, i, uint64(len(m.RecoveredDatumsObject)))
		i--
		dAtA[i] = 0x3a
	}
	if m.StatsHashtree != nil {
		{
			size, err := m.StatsHashtree.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransform(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.ChunkHashtree != nil {
		{
			size, err := m.ChunkHashtree.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransform(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Stats != nil {
		{
			size, err := m.Stats.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransform(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.OutputCommit != nil {
		{
			size, err := m.OutputCommit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransform(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.JobID) > 0 {
		i -= len(m.JobID)
		copy(dAtA[i:], m.JobID)
		i = encodeVarintTransform(dAtA, i, uint64(len(m.JobID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func (m *MergeData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.TreeSize != 0 {
		i = encodeVarintTransform(dAtA, i, uint64(m.TreeSize))
		i--
		dAtA[i] = 0x38
	}
	if m.Tree != nil {
		{
			size, err := m.Tree.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransform(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Stats {
		i--
		if m.Stats {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Shard != 0 {
		i = encodeVarintTransform(dAtA, i, uint64(m.Shard))
		i--
		dAtA[i] = 0x20
	}
	if m.Parent != nil {
		{
			size, err := m.Parent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransform(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Hashtrees) > 0 {
		for iNdEx := len(m.Hashtrees) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Hashtrees[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTransform(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.JobID) > 0 {
		i -= len(m.JobID)
		copy(dAtA[i:], m.JobID)
		i = encodeVarintTransform(dAtA, i, uint64(len(m.JobID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintTransform(dAtA []byte, offset int, v uint64) int {
	offset -= sovTransform(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DatumInputs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Inputs) > 0 {
		for _, e := range m.Inputs {
			l = e.Size()
			n += 1 + l + sovTransform(uint64(l))
		}
	}
	if m.Index != 0 {
		n += 1 + sovTransform(uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DatumInputsList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Datums) > 0 {
		for _, e := range m.Datums {
			l = e.Size()
			n += 1 + l + sovTransform(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HashtreeObjects) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ChunkObjects) > 0 {
		for _, s := range m.ChunkObjects {
			l = len(s)
			n += 1 + l + sovTransform(uint64(l))
		}
	}
	if len(m.StatsObjects) > 0 {
		for _, s := range m.StatsObjects {
			l = len(s)
			n += 1 + l + sovTransform(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RecoveredDatums) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Hashes) > 0 {
		for _, s := range m.Hashes {
			l = len(s)
			n += 1 + l + sovTransform(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RecoveredDatumObjects) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Objects) > 0 {
		for _, s := range m.Objects {
			l = len(s)
			n += 1 + l + sovTransform(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HashtreeInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovTransform(uint64(l))
	}
	l = len(m.SubtaskID)
	if l > 0 {
		n += 1 + l + sovTransform(uint64(l))
	}
	l = len(m.Object)
	if l > 0 {
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DatumStats) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ProcessStats != nil {
		l = m.ProcessStats.Size()
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.DatumsProcessed != 0 {
		n += 1 + sovTransform(uint64(m.DatumsProcessed))
	}
	if m.DatumsSkipped != 0 {
		n += 1 + sovTransform(uint64(m.DatumsSkipped))
	}
	if m.DatumsFailed != 0 {
		n += 1 + sovTransform(uint64(m.DatumsFailed))
	}
	if m.DatumsRecovered != 0 {
		n += 1 + sovTransform(uint64(m.DatumsRecovered))
	}
	l = len(m.FailedDatumID)
	if l > 0 {
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DatumData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.JobID)
	if l > 0 {
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.OutputCommit != nil {
		l = m.OutputCommit.Size()
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.Stats != nil {
		l = m.Stats.Size()
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.ChunkHashtree != nil {
		l = m.ChunkHashtree.Size()
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.StatsHashtree != nil {
		l = m.StatsHashtree.Size()
		n += 1 + l + sovTransform(uint64(l))
	}
	l = len(m.RecoveredDatumsObject)
	if l > 0 {
		n += 1 + l + sovTransform(uint64(l))
	}
	l = len(m.DatumsObject)
	if l > 0 {
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MergeData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.JobID)
	if l > 0 {
		n += 1 + l + sovTransform(uint64(l))
	}
	if len(m.Hashtrees) > 0 {
		for _, e := range m.Hashtrees {
			l = e.Size()
			n += 1 + l + sovTransform(uint64(l))
		}
	}
	if m.Parent != nil {
		l = m.Parent.Size()
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.Shard != 0 {
		n += 1 + sovTransform(uint64(m.Shard))
	}
	if m.Stats {
		n += 2
	}
	if m.Tree != nil {
		l = m.Tree.Size()
		n += 1 + l + sovTransform(uint64(l))
	}
	if m.TreeSize != 0 {
		n += 1 + sovTransform(uint64(m.TreeSize))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovTransform(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTransform(x uint64) (n int) {
	return sovTransform(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DatumInputs) 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 ErrIntOverflowTransform
			}
			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: DatumInputs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DatumInputs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Inputs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Inputs = append(m.Inputs, &common.Input{})
			if err := m.Inputs[len(m.Inputs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTransform(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransform
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HashtreeObjects) 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 ErrIntOverflowTransform
			}
			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: HashtreeObjects: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HashtreeObjects: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChunkObjects", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChunkObjects = append(m.ChunkObjects, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatsObjects", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StatsObjects = append(m.StatsObjects, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTransform(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransform
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *HashtreeInfo) 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 ErrIntOverflowTransform
			}
			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: HashtreeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: HashtreeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubtaskID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SubtaskID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Object", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Object = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTransform(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransform
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DatumStats) 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 ErrIntOverflowTransform
			}
			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: DatumStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DatumStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessStats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProcessStats == nil {
				m.ProcessStats = &pps.ProcessStats{}
			}
			if err := m.ProcessStats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatumsProcessed", wireType)
			}
			m.DatumsProcessed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DatumsProcessed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatumsSkipped", wireType)
			}
			m.DatumsSkipped = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DatumsSkipped |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatumsFailed", wireType)
			}
			m.DatumsFailed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DatumsFailed |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatumsRecovered", wireType)
			}
			m.DatumsRecovered = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DatumsRecovered |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailedDatumID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FailedDatumID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTransform(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransform
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DatumData) 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 ErrIntOverflowTransform
			}
			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: DatumData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DatumData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutputCommit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OutputCommit == nil {
				m.OutputCommit = &pfs.Commit{}
			}
			if err := m.OutputCommit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Stats == nil {
				m.Stats = &DatumStats{}
			}
			if err := m.Stats.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChunkHashtree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ChunkHashtree == nil {
				m.ChunkHashtree = &HashtreeInfo{}
			}
			if err := m.ChunkHashtree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatsHashtree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StatsHashtree == nil {
				m.StatsHashtree = &HashtreeInfo{}
			}
			if err := m.StatsHashtree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecoveredDatumsObject", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecoveredDatumsObject = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DatumsObject", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DatumsObject = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTransform(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransform
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MergeData) 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 ErrIntOverflowTransform
			}
			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: MergeData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MergeData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				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 ErrInvalidLengthTransform
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hashtrees", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hashtrees = append(m.Hashtrees, &HashtreeInfo{})
			if err := m.Hashtrees[len(m.Hashtrees)-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 Parent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Parent == nil {
				m.Parent = &pfs.Object{}
			}
			if err := m.Parent.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Shard", wireType)
			}
			m.Shard = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Shard |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Stats", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Stats = bool(v != 0)
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransform
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransform
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Tree == nil {
				m.Tree = &pfs.Object{}
			}
			if err := m.Tree.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TreeSize", wireType)
			}
			m.TreeSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransform
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TreeSize |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTransform(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransform
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTransform(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, ErrIntOverflowTransform
			}
			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, ErrIntOverflowTransform
				}
				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, ErrIntOverflowTransform
				}
				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, ErrInvalidLengthTransform
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTransform
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTransform
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthTransform        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTransform          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTransform = fmt.Errorf("proto: unexpected end of group")
)