// Code generated by protoc-gen-go-lite. DO NOT EDIT.
// protoc-gen-go-lite version: v0.14.0
// source: stats.proto

package stats

import (
	fmt "fmt"
	protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
	io "io"
	slices "slices"
	strconv "strconv"
	strings "strings"
)

// SPDX-License-Identifier: MIT

// This one contains statistics about dump/restore process
type DumpStatsEntry struct {
	unknownFields        []byte
	FreezingTime         *uint32 `protobuf:"varint,1,req,name=freezing_time,json=freezingTime" json:"freezingTime,omitempty"`
	FrozenTime           *uint32 `protobuf:"varint,2,req,name=frozen_time,json=frozenTime" json:"frozenTime,omitempty"`
	MemdumpTime          *uint32 `protobuf:"varint,3,req,name=memdump_time,json=memdumpTime" json:"memdumpTime,omitempty"`
	MemwriteTime         *uint32 `protobuf:"varint,4,req,name=memwrite_time,json=memwriteTime" json:"memwriteTime,omitempty"`
	PagesScanned         *uint64 `protobuf:"varint,5,req,name=pages_scanned,json=pagesScanned" json:"pagesScanned,omitempty"`
	PagesSkippedParent   *uint64 `protobuf:"varint,6,req,name=pages_skipped_parent,json=pagesSkippedParent" json:"pagesSkippedParent,omitempty"`
	PagesWritten         *uint64 `protobuf:"varint,7,req,name=pages_written,json=pagesWritten" json:"pagesWritten,omitempty"`
	IrmapResolve         *uint32 `protobuf:"varint,8,opt,name=irmap_resolve,json=irmapResolve" json:"irmapResolve,omitempty"`
	PagesLazy            *uint64 `protobuf:"varint,9,req,name=pages_lazy,json=pagesLazy" json:"pagesLazy,omitempty"`
	PagePipes            *uint64 `protobuf:"varint,10,opt,name=page_pipes,json=pagePipes" json:"pagePipes,omitempty"`
	PagePipeBufs         *uint64 `protobuf:"varint,11,opt,name=page_pipe_bufs,json=pagePipeBufs" json:"pagePipeBufs,omitempty"`
	ShpagesScanned       *uint64 `protobuf:"varint,12,opt,name=shpages_scanned,json=shpagesScanned" json:"shpagesScanned,omitempty"`
	ShpagesSkippedParent *uint64 `protobuf:"varint,13,opt,name=shpages_skipped_parent,json=shpagesSkippedParent" json:"shpagesSkippedParent,omitempty"`
	ShpagesWritten       *uint64 `protobuf:"varint,14,opt,name=shpages_written,json=shpagesWritten" json:"shpagesWritten,omitempty"`
}

func (x *DumpStatsEntry) Reset() {
	*x = DumpStatsEntry{}
}

func (*DumpStatsEntry) ProtoMessage() {}

func (x *DumpStatsEntry) GetFreezingTime() uint32 {
	if x != nil && x.FreezingTime != nil {
		return *x.FreezingTime
	}
	return 0
}

func (x *DumpStatsEntry) GetFrozenTime() uint32 {
	if x != nil && x.FrozenTime != nil {
		return *x.FrozenTime
	}
	return 0
}

func (x *DumpStatsEntry) GetMemdumpTime() uint32 {
	if x != nil && x.MemdumpTime != nil {
		return *x.MemdumpTime
	}
	return 0
}

func (x *DumpStatsEntry) GetMemwriteTime() uint32 {
	if x != nil && x.MemwriteTime != nil {
		return *x.MemwriteTime
	}
	return 0
}

func (x *DumpStatsEntry) GetPagesScanned() uint64 {
	if x != nil && x.PagesScanned != nil {
		return *x.PagesScanned
	}
	return 0
}

func (x *DumpStatsEntry) GetPagesSkippedParent() uint64 {
	if x != nil && x.PagesSkippedParent != nil {
		return *x.PagesSkippedParent
	}
	return 0
}

func (x *DumpStatsEntry) GetPagesWritten() uint64 {
	if x != nil && x.PagesWritten != nil {
		return *x.PagesWritten
	}
	return 0
}

func (x *DumpStatsEntry) GetIrmapResolve() uint32 {
	if x != nil && x.IrmapResolve != nil {
		return *x.IrmapResolve
	}
	return 0
}

func (x *DumpStatsEntry) GetPagesLazy() uint64 {
	if x != nil && x.PagesLazy != nil {
		return *x.PagesLazy
	}
	return 0
}

func (x *DumpStatsEntry) GetPagePipes() uint64 {
	if x != nil && x.PagePipes != nil {
		return *x.PagePipes
	}
	return 0
}

func (x *DumpStatsEntry) GetPagePipeBufs() uint64 {
	if x != nil && x.PagePipeBufs != nil {
		return *x.PagePipeBufs
	}
	return 0
}

func (x *DumpStatsEntry) GetShpagesScanned() uint64 {
	if x != nil && x.ShpagesScanned != nil {
		return *x.ShpagesScanned
	}
	return 0
}

func (x *DumpStatsEntry) GetShpagesSkippedParent() uint64 {
	if x != nil && x.ShpagesSkippedParent != nil {
		return *x.ShpagesSkippedParent
	}
	return 0
}

func (x *DumpStatsEntry) GetShpagesWritten() uint64 {
	if x != nil && x.ShpagesWritten != nil {
		return *x.ShpagesWritten
	}
	return 0
}

type RestoreStatsEntry struct {
	unknownFields   []byte
	PagesCompared   *uint64 `protobuf:"varint,1,req,name=pages_compared,json=pagesCompared" json:"pagesCompared,omitempty"`
	PagesSkippedCow *uint64 `protobuf:"varint,2,req,name=pages_skipped_cow,json=pagesSkippedCow" json:"pagesSkippedCow,omitempty"`
	ForkingTime     *uint32 `protobuf:"varint,3,req,name=forking_time,json=forkingTime" json:"forkingTime,omitempty"`
	RestoreTime     *uint32 `protobuf:"varint,4,req,name=restore_time,json=restoreTime" json:"restoreTime,omitempty"`
	PagesRestored   *uint64 `protobuf:"varint,5,opt,name=pages_restored,json=pagesRestored" json:"pagesRestored,omitempty"`
}

func (x *RestoreStatsEntry) Reset() {
	*x = RestoreStatsEntry{}
}

func (*RestoreStatsEntry) ProtoMessage() {}

func (x *RestoreStatsEntry) GetPagesCompared() uint64 {
	if x != nil && x.PagesCompared != nil {
		return *x.PagesCompared
	}
	return 0
}

func (x *RestoreStatsEntry) GetPagesSkippedCow() uint64 {
	if x != nil && x.PagesSkippedCow != nil {
		return *x.PagesSkippedCow
	}
	return 0
}

func (x *RestoreStatsEntry) GetForkingTime() uint32 {
	if x != nil && x.ForkingTime != nil {
		return *x.ForkingTime
	}
	return 0
}

func (x *RestoreStatsEntry) GetRestoreTime() uint32 {
	if x != nil && x.RestoreTime != nil {
		return *x.RestoreTime
	}
	return 0
}

func (x *RestoreStatsEntry) GetPagesRestored() uint64 {
	if x != nil && x.PagesRestored != nil {
		return *x.PagesRestored
	}
	return 0
}

type StatsEntry struct {
	unknownFields []byte
	Dump          *DumpStatsEntry    `protobuf:"bytes,1,opt,name=dump" json:"dump,omitempty"`
	Restore       *RestoreStatsEntry `protobuf:"bytes,2,opt,name=restore" json:"restore,omitempty"`
}

func (x *StatsEntry) Reset() {
	*x = StatsEntry{}
}

func (*StatsEntry) ProtoMessage() {}

func (x *StatsEntry) GetDump() *DumpStatsEntry {
	if x != nil {
		return x.Dump
	}
	return nil
}

func (x *StatsEntry) GetRestore() *RestoreStatsEntry {
	if x != nil {
		return x.Restore
	}
	return nil
}

func (m *DumpStatsEntry) CloneVT() *DumpStatsEntry {
	if m == nil {
		return (*DumpStatsEntry)(nil)
	}
	r := new(DumpStatsEntry)
	if rhs := m.FreezingTime; rhs != nil {
		tmpVal := *rhs
		r.FreezingTime = &tmpVal
	}
	if rhs := m.FrozenTime; rhs != nil {
		tmpVal := *rhs
		r.FrozenTime = &tmpVal
	}
	if rhs := m.MemdumpTime; rhs != nil {
		tmpVal := *rhs
		r.MemdumpTime = &tmpVal
	}
	if rhs := m.MemwriteTime; rhs != nil {
		tmpVal := *rhs
		r.MemwriteTime = &tmpVal
	}
	if rhs := m.PagesScanned; rhs != nil {
		tmpVal := *rhs
		r.PagesScanned = &tmpVal
	}
	if rhs := m.PagesSkippedParent; rhs != nil {
		tmpVal := *rhs
		r.PagesSkippedParent = &tmpVal
	}
	if rhs := m.PagesWritten; rhs != nil {
		tmpVal := *rhs
		r.PagesWritten = &tmpVal
	}
	if rhs := m.IrmapResolve; rhs != nil {
		tmpVal := *rhs
		r.IrmapResolve = &tmpVal
	}
	if rhs := m.PagesLazy; rhs != nil {
		tmpVal := *rhs
		r.PagesLazy = &tmpVal
	}
	if rhs := m.PagePipes; rhs != nil {
		tmpVal := *rhs
		r.PagePipes = &tmpVal
	}
	if rhs := m.PagePipeBufs; rhs != nil {
		tmpVal := *rhs
		r.PagePipeBufs = &tmpVal
	}
	if rhs := m.ShpagesScanned; rhs != nil {
		tmpVal := *rhs
		r.ShpagesScanned = &tmpVal
	}
	if rhs := m.ShpagesSkippedParent; rhs != nil {
		tmpVal := *rhs
		r.ShpagesSkippedParent = &tmpVal
	}
	if rhs := m.ShpagesWritten; rhs != nil {
		tmpVal := *rhs
		r.ShpagesWritten = &tmpVal
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *DumpStatsEntry) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RestoreStatsEntry) CloneVT() *RestoreStatsEntry {
	if m == nil {
		return (*RestoreStatsEntry)(nil)
	}
	r := new(RestoreStatsEntry)
	if rhs := m.PagesCompared; rhs != nil {
		tmpVal := *rhs
		r.PagesCompared = &tmpVal
	}
	if rhs := m.PagesSkippedCow; rhs != nil {
		tmpVal := *rhs
		r.PagesSkippedCow = &tmpVal
	}
	if rhs := m.ForkingTime; rhs != nil {
		tmpVal := *rhs
		r.ForkingTime = &tmpVal
	}
	if rhs := m.RestoreTime; rhs != nil {
		tmpVal := *rhs
		r.RestoreTime = &tmpVal
	}
	if rhs := m.PagesRestored; rhs != nil {
		tmpVal := *rhs
		r.PagesRestored = &tmpVal
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *RestoreStatsEntry) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *StatsEntry) CloneVT() *StatsEntry {
	if m == nil {
		return (*StatsEntry)(nil)
	}
	r := new(StatsEntry)
	r.Dump = m.Dump.CloneVT()
	r.Restore = m.Restore.CloneVT()
	if len(m.unknownFields) > 0 {
		r.unknownFields = slices.Clone(m.unknownFields)
	}
	return r
}

func (m *StatsEntry) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (this *DumpStatsEntry) EqualVT(that *DumpStatsEntry) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.FreezingTime, that.FreezingTime; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.FrozenTime, that.FrozenTime; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.MemdumpTime, that.MemdumpTime; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.MemwriteTime, that.MemwriteTime; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.PagesScanned, that.PagesScanned; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.PagesSkippedParent, that.PagesSkippedParent; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.PagesWritten, that.PagesWritten; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.IrmapResolve, that.IrmapResolve; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.PagesLazy, that.PagesLazy; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.PagePipes, that.PagePipes; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.PagePipeBufs, that.PagePipeBufs; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.ShpagesScanned, that.ShpagesScanned; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.ShpagesSkippedParent, that.ShpagesSkippedParent; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.ShpagesWritten, that.ShpagesWritten; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *DumpStatsEntry) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*DumpStatsEntry)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RestoreStatsEntry) EqualVT(that *RestoreStatsEntry) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if p, q := this.PagesCompared, that.PagesCompared; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.PagesSkippedCow, that.PagesSkippedCow; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.ForkingTime, that.ForkingTime; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.RestoreTime, that.RestoreTime; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	if p, q := this.PagesRestored, that.PagesRestored; (p == nil && q != nil) || (p != nil && (q == nil || *p != *q)) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RestoreStatsEntry) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RestoreStatsEntry)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *StatsEntry) EqualVT(that *StatsEntry) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if !this.Dump.EqualVT(that.Dump) {
		return false
	}
	if !this.Restore.EqualVT(that.Restore) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *StatsEntry) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*StatsEntry)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

// NOTE: protobuf-go-lite json only supports proto3 and editions: proto2 is not supported.

func (m *DumpStatsEntry) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DumpStatsEntry) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *DumpStatsEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.ShpagesWritten != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.ShpagesWritten))
		i--
		dAtA[i] = 0x70
	}
	if m.ShpagesSkippedParent != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.ShpagesSkippedParent))
		i--
		dAtA[i] = 0x68
	}
	if m.ShpagesScanned != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.ShpagesScanned))
		i--
		dAtA[i] = 0x60
	}
	if m.PagePipeBufs != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagePipeBufs))
		i--
		dAtA[i] = 0x58
	}
	if m.PagePipes != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagePipes))
		i--
		dAtA[i] = 0x50
	}
	if m.PagesLazy == nil {
		return 0, fmt.Errorf("proto: required field pages_lazy not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesLazy))
		i--
		dAtA[i] = 0x48
	}
	if m.IrmapResolve != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.IrmapResolve))
		i--
		dAtA[i] = 0x40
	}
	if m.PagesWritten == nil {
		return 0, fmt.Errorf("proto: required field pages_written not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesWritten))
		i--
		dAtA[i] = 0x38
	}
	if m.PagesSkippedParent == nil {
		return 0, fmt.Errorf("proto: required field pages_skipped_parent not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesSkippedParent))
		i--
		dAtA[i] = 0x30
	}
	if m.PagesScanned == nil {
		return 0, fmt.Errorf("proto: required field pages_scanned not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesScanned))
		i--
		dAtA[i] = 0x28
	}
	if m.MemwriteTime == nil {
		return 0, fmt.Errorf("proto: required field memwrite_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.MemwriteTime))
		i--
		dAtA[i] = 0x20
	}
	if m.MemdumpTime == nil {
		return 0, fmt.Errorf("proto: required field memdump_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.MemdumpTime))
		i--
		dAtA[i] = 0x18
	}
	if m.FrozenTime == nil {
		return 0, fmt.Errorf("proto: required field frozen_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.FrozenTime))
		i--
		dAtA[i] = 0x10
	}
	if m.FreezingTime == nil {
		return 0, fmt.Errorf("proto: required field freezing_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.FreezingTime))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RestoreStatsEntry) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RestoreStatsEntry) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RestoreStatsEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.PagesRestored != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesRestored))
		i--
		dAtA[i] = 0x28
	}
	if m.RestoreTime == nil {
		return 0, fmt.Errorf("proto: required field restore_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RestoreTime))
		i--
		dAtA[i] = 0x20
	}
	if m.ForkingTime == nil {
		return 0, fmt.Errorf("proto: required field forking_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.ForkingTime))
		i--
		dAtA[i] = 0x18
	}
	if m.PagesSkippedCow == nil {
		return 0, fmt.Errorf("proto: required field pages_skipped_cow not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesSkippedCow))
		i--
		dAtA[i] = 0x10
	}
	if m.PagesCompared == nil {
		return 0, fmt.Errorf("proto: required field pages_compared not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesCompared))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StatsEntry) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StatsEntry) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *StatsEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.Restore != nil {
		size, err := m.Restore.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	}
	if m.Dump != nil {
		size, err := m.Dump.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DumpStatsEntry) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DumpStatsEntry) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *DumpStatsEntry) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.ShpagesWritten != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.ShpagesWritten))
		i--
		dAtA[i] = 0x70
	}
	if m.ShpagesSkippedParent != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.ShpagesSkippedParent))
		i--
		dAtA[i] = 0x68
	}
	if m.ShpagesScanned != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.ShpagesScanned))
		i--
		dAtA[i] = 0x60
	}
	if m.PagePipeBufs != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagePipeBufs))
		i--
		dAtA[i] = 0x58
	}
	if m.PagePipes != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagePipes))
		i--
		dAtA[i] = 0x50
	}
	if m.PagesLazy == nil {
		return 0, fmt.Errorf("proto: required field pages_lazy not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesLazy))
		i--
		dAtA[i] = 0x48
	}
	if m.IrmapResolve != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.IrmapResolve))
		i--
		dAtA[i] = 0x40
	}
	if m.PagesWritten == nil {
		return 0, fmt.Errorf("proto: required field pages_written not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesWritten))
		i--
		dAtA[i] = 0x38
	}
	if m.PagesSkippedParent == nil {
		return 0, fmt.Errorf("proto: required field pages_skipped_parent not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesSkippedParent))
		i--
		dAtA[i] = 0x30
	}
	if m.PagesScanned == nil {
		return 0, fmt.Errorf("proto: required field pages_scanned not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesScanned))
		i--
		dAtA[i] = 0x28
	}
	if m.MemwriteTime == nil {
		return 0, fmt.Errorf("proto: required field memwrite_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.MemwriteTime))
		i--
		dAtA[i] = 0x20
	}
	if m.MemdumpTime == nil {
		return 0, fmt.Errorf("proto: required field memdump_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.MemdumpTime))
		i--
		dAtA[i] = 0x18
	}
	if m.FrozenTime == nil {
		return 0, fmt.Errorf("proto: required field frozen_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.FrozenTime))
		i--
		dAtA[i] = 0x10
	}
	if m.FreezingTime == nil {
		return 0, fmt.Errorf("proto: required field freezing_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.FreezingTime))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RestoreStatsEntry) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RestoreStatsEntry) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *RestoreStatsEntry) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.PagesRestored != nil {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesRestored))
		i--
		dAtA[i] = 0x28
	}
	if m.RestoreTime == nil {
		return 0, fmt.Errorf("proto: required field restore_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.RestoreTime))
		i--
		dAtA[i] = 0x20
	}
	if m.ForkingTime == nil {
		return 0, fmt.Errorf("proto: required field forking_time not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.ForkingTime))
		i--
		dAtA[i] = 0x18
	}
	if m.PagesSkippedCow == nil {
		return 0, fmt.Errorf("proto: required field pages_skipped_cow not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesSkippedCow))
		i--
		dAtA[i] = 0x10
	}
	if m.PagesCompared == nil {
		return 0, fmt.Errorf("proto: required field pages_compared not set")
	} else {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(*m.PagesCompared))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StatsEntry) MarshalVTStrict() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVTStrict(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StatsEntry) MarshalToVTStrict(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVTStrict(dAtA[:size])
}

func (m *StatsEntry) MarshalToSizedBufferVTStrict(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.Restore != nil {
		size, err := m.Restore.MarshalToSizedBufferVTStrict(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	}
	if m.Dump != nil {
		size, err := m.Dump.MarshalToSizedBufferVTStrict(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DumpStatsEntry) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.FreezingTime != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.FreezingTime))
	}
	if m.FrozenTime != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.FrozenTime))
	}
	if m.MemdumpTime != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.MemdumpTime))
	}
	if m.MemwriteTime != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.MemwriteTime))
	}
	if m.PagesScanned != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagesScanned))
	}
	if m.PagesSkippedParent != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagesSkippedParent))
	}
	if m.PagesWritten != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagesWritten))
	}
	if m.IrmapResolve != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.IrmapResolve))
	}
	if m.PagesLazy != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagesLazy))
	}
	if m.PagePipes != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagePipes))
	}
	if m.PagePipeBufs != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagePipeBufs))
	}
	if m.ShpagesScanned != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.ShpagesScanned))
	}
	if m.ShpagesSkippedParent != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.ShpagesSkippedParent))
	}
	if m.ShpagesWritten != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.ShpagesWritten))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RestoreStatsEntry) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PagesCompared != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagesCompared))
	}
	if m.PagesSkippedCow != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagesSkippedCow))
	}
	if m.ForkingTime != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.ForkingTime))
	}
	if m.RestoreTime != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.RestoreTime))
	}
	if m.PagesRestored != nil {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(*m.PagesRestored))
	}
	n += len(m.unknownFields)
	return n
}

func (m *StatsEntry) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Dump != nil {
		l = m.Dump.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.Restore != nil {
		l = m.Restore.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (x *DumpStatsEntry) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("dump_stats_entry {")
	if x.FreezingTime != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("freezing_time: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.FreezingTime), 10))
	}
	if x.FrozenTime != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("frozen_time: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.FrozenTime), 10))
	}
	if x.MemdumpTime != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("memdump_time: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.MemdumpTime), 10))
	}
	if x.MemwriteTime != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("memwrite_time: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.MemwriteTime), 10))
	}
	if x.PagesScanned != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("pages_scanned: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagesScanned), 10))
	}
	if x.PagesSkippedParent != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("pages_skipped_parent: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagesSkippedParent), 10))
	}
	if x.PagesWritten != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("pages_written: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagesWritten), 10))
	}
	if x.IrmapResolve != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("irmap_resolve: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.IrmapResolve), 10))
	}
	if x.PagesLazy != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("pages_lazy: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagesLazy), 10))
	}
	if x.PagePipes != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("page_pipes: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagePipes), 10))
	}
	if x.PagePipeBufs != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("page_pipe_bufs: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagePipeBufs), 10))
	}
	if x.ShpagesScanned != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("shpages_scanned: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.ShpagesScanned), 10))
	}
	if x.ShpagesSkippedParent != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("shpages_skipped_parent: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.ShpagesSkippedParent), 10))
	}
	if x.ShpagesWritten != nil {
		if sb.Len() > 18 {
			sb.WriteString(" ")
		}
		sb.WriteString("shpages_written: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.ShpagesWritten), 10))
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *DumpStatsEntry) String() string {
	return x.MarshalProtoText()
}
func (x *RestoreStatsEntry) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("restore_stats_entry {")
	if x.PagesCompared != nil {
		if sb.Len() > 21 {
			sb.WriteString(" ")
		}
		sb.WriteString("pages_compared: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagesCompared), 10))
	}
	if x.PagesSkippedCow != nil {
		if sb.Len() > 21 {
			sb.WriteString(" ")
		}
		sb.WriteString("pages_skipped_cow: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagesSkippedCow), 10))
	}
	if x.ForkingTime != nil {
		if sb.Len() > 21 {
			sb.WriteString(" ")
		}
		sb.WriteString("forking_time: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.ForkingTime), 10))
	}
	if x.RestoreTime != nil {
		if sb.Len() > 21 {
			sb.WriteString(" ")
		}
		sb.WriteString("restore_time: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.RestoreTime), 10))
	}
	if x.PagesRestored != nil {
		if sb.Len() > 21 {
			sb.WriteString(" ")
		}
		sb.WriteString("pages_restored: ")
		sb.WriteString(strconv.FormatUint(uint64(*x.PagesRestored), 10))
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *RestoreStatsEntry) String() string {
	return x.MarshalProtoText()
}
func (x *StatsEntry) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("stats_entry {")
	if x.Dump != nil {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("dump: ")
		sb.WriteString(x.Dump.MarshalProtoText())
	}
	if x.Restore != nil {
		if sb.Len() > 13 {
			sb.WriteString(" ")
		}
		sb.WriteString("restore: ")
		sb.WriteString(x.Restore.MarshalProtoText())
	}
	sb.WriteString("}")
	return sb.String()
}

func (x *StatsEntry) String() string {
	return x.MarshalProtoText()
}
func (m *DumpStatsEntry) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DumpStatsEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DumpStatsEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FreezingTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.FreezingTime = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrozenTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.FrozenTime = &v
			hasFields[0] |= uint64(0x00000002)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemdumpTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.MemdumpTime = &v
			hasFields[0] |= uint64(0x00000004)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemwriteTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.MemwriteTime = &v
			hasFields[0] |= uint64(0x00000008)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesScanned", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesScanned = &v
			hasFields[0] |= uint64(0x00000010)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesSkippedParent", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesSkippedParent = &v
			hasFields[0] |= uint64(0x00000020)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesWritten", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesWritten = &v
			hasFields[0] |= uint64(0x00000040)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IrmapResolve", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.IrmapResolve = &v
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesLazy", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesLazy = &v
			hasFields[0] |= uint64(0x00000080)
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagePipes", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagePipes = &v
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagePipeBufs", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagePipeBufs = &v
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShpagesScanned", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.ShpagesScanned = &v
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShpagesSkippedParent", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.ShpagesSkippedParent = &v
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShpagesWritten", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.ShpagesWritten = &v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field freezing_time not set")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return fmt.Errorf("proto: required field frozen_time not set")
	}
	if hasFields[0]&uint64(0x00000004) == 0 {
		return fmt.Errorf("proto: required field memdump_time not set")
	}
	if hasFields[0]&uint64(0x00000008) == 0 {
		return fmt.Errorf("proto: required field memwrite_time not set")
	}
	if hasFields[0]&uint64(0x00000010) == 0 {
		return fmt.Errorf("proto: required field pages_scanned not set")
	}
	if hasFields[0]&uint64(0x00000020) == 0 {
		return fmt.Errorf("proto: required field pages_skipped_parent not set")
	}
	if hasFields[0]&uint64(0x00000040) == 0 {
		return fmt.Errorf("proto: required field pages_written not set")
	}
	if hasFields[0]&uint64(0x00000080) == 0 {
		return fmt.Errorf("proto: required field pages_lazy not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RestoreStatsEntry) UnmarshalVT(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RestoreStatsEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RestoreStatsEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesCompared", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesCompared = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesSkippedCow", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesSkippedCow = &v
			hasFields[0] |= uint64(0x00000002)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForkingTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.ForkingTime = &v
			hasFields[0] |= uint64(0x00000004)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestoreTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.RestoreTime = &v
			hasFields[0] |= uint64(0x00000008)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesRestored", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesRestored = &v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field pages_compared not set")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return fmt.Errorf("proto: required field pages_skipped_cow not set")
	}
	if hasFields[0]&uint64(0x00000004) == 0 {
		return fmt.Errorf("proto: required field forking_time not set")
	}
	if hasFields[0]&uint64(0x00000008) == 0 {
		return fmt.Errorf("proto: required field restore_time not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StatsEntry) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StatsEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatsEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dump", wireType)
			}
			var msglen int
			var _v uint64
			_v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			msglen = int(_v)
			if err != nil {
				return err
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dump == nil {
				m.Dump = &DumpStatsEntry{}
			}
			if err := m.Dump.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Restore", wireType)
			}
			var msglen int
			var _v uint64
			_v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			msglen = int(_v)
			if err != nil {
				return err
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Restore == nil {
				m.Restore = &RestoreStatsEntry{}
			}
			if err := m.Restore.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DumpStatsEntry) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DumpStatsEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DumpStatsEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FreezingTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.FreezingTime = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrozenTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.FrozenTime = &v
			hasFields[0] |= uint64(0x00000002)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemdumpTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.MemdumpTime = &v
			hasFields[0] |= uint64(0x00000004)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemwriteTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.MemwriteTime = &v
			hasFields[0] |= uint64(0x00000008)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesScanned", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesScanned = &v
			hasFields[0] |= uint64(0x00000010)
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesSkippedParent", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesSkippedParent = &v
			hasFields[0] |= uint64(0x00000020)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesWritten", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesWritten = &v
			hasFields[0] |= uint64(0x00000040)
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IrmapResolve", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.IrmapResolve = &v
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesLazy", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesLazy = &v
			hasFields[0] |= uint64(0x00000080)
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagePipes", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagePipes = &v
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagePipeBufs", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagePipeBufs = &v
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShpagesScanned", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.ShpagesScanned = &v
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShpagesSkippedParent", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.ShpagesSkippedParent = &v
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShpagesWritten", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.ShpagesWritten = &v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field freezing_time not set")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return fmt.Errorf("proto: required field frozen_time not set")
	}
	if hasFields[0]&uint64(0x00000004) == 0 {
		return fmt.Errorf("proto: required field memdump_time not set")
	}
	if hasFields[0]&uint64(0x00000008) == 0 {
		return fmt.Errorf("proto: required field memwrite_time not set")
	}
	if hasFields[0]&uint64(0x00000010) == 0 {
		return fmt.Errorf("proto: required field pages_scanned not set")
	}
	if hasFields[0]&uint64(0x00000020) == 0 {
		return fmt.Errorf("proto: required field pages_skipped_parent not set")
	}
	if hasFields[0]&uint64(0x00000040) == 0 {
		return fmt.Errorf("proto: required field pages_written not set")
	}
	if hasFields[0]&uint64(0x00000080) == 0 {
		return fmt.Errorf("proto: required field pages_lazy not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RestoreStatsEntry) UnmarshalVTUnsafe(dAtA []byte) error {
	var hasFields [1]uint64
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RestoreStatsEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RestoreStatsEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesCompared", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesCompared = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesSkippedCow", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesSkippedCow = &v
			hasFields[0] |= uint64(0x00000002)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForkingTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.ForkingTime = &v
			hasFields[0] |= uint64(0x00000004)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RestoreTime", wireType)
			}
			var v uint32
			v, iNdEx, err = protobuf_go_lite.DecodeVarintUint32(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.RestoreTime = &v
			hasFields[0] |= uint64(0x00000008)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PagesRestored", wireType)
			}
			var v uint64
			v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			if err != nil {
				return err
			}
			m.PagesRestored = &v
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return fmt.Errorf("proto: required field pages_compared not set")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return fmt.Errorf("proto: required field pages_skipped_cow not set")
	}
	if hasFields[0]&uint64(0x00000004) == 0 {
		return fmt.Errorf("proto: required field forking_time not set")
	}
	if hasFields[0]&uint64(0x00000008) == 0 {
		return fmt.Errorf("proto: required field restore_time not set")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StatsEntry) UnmarshalVTUnsafe(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	var err error
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		wire, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
		if err != nil {
			return err
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StatsEntry: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatsEntry: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dump", wireType)
			}
			var msglen int
			var _v uint64
			_v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			msglen = int(_v)
			if err != nil {
				return err
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Dump == nil {
				m.Dump = &DumpStatsEntry{}
			}
			if err := m.Dump.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Restore", wireType)
			}
			var msglen int
			var _v uint64
			_v, iNdEx, err = protobuf_go_lite.DecodeVarint(dAtA, iNdEx)
			msglen = int(_v)
			if err != nil {
				return err
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Restore == nil {
				m.Restore = &RestoreStatsEntry{}
			}
			if err := m.Restore.UnmarshalVTUnsafe(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
