// automatically generated by stateify.

package pgalloc

import (
	"gvisor.dev/gvisor/pkg/state"
)

func (x *EvictableRange) StateTypeName() string {
	return "pkg/sentry/pgalloc.EvictableRange"
}

func (x *EvictableRange) StateFields() []string {
	return []string{
		"Start",
		"End",
	}
}

func (x *EvictableRange) beforeSave() {}

func (x *EvictableRange) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Start)
	m.Save(1, &x.End)
}

func (x *EvictableRange) afterLoad() {}

func (x *EvictableRange) StateLoad(m state.Source) {
	m.Load(0, &x.Start)
	m.Load(1, &x.End)
}

func (x *evictableRangeSet) StateTypeName() string {
	return "pkg/sentry/pgalloc.evictableRangeSet"
}

func (x *evictableRangeSet) StateFields() []string {
	return []string{
		"root",
	}
}

func (x *evictableRangeSet) beforeSave() {}

func (x *evictableRangeSet) StateSave(m state.Sink) {
	x.beforeSave()
	var root *evictableRangeSegmentDataSlices = x.saveRoot()
	m.SaveValue(0, root)
}

func (x *evictableRangeSet) afterLoad() {}

func (x *evictableRangeSet) StateLoad(m state.Source) {
	m.LoadValue(0, new(*evictableRangeSegmentDataSlices), func(y interface{}) { x.loadRoot(y.(*evictableRangeSegmentDataSlices)) })
}

func (x *evictableRangenode) StateTypeName() string {
	return "pkg/sentry/pgalloc.evictableRangenode"
}

func (x *evictableRangenode) StateFields() []string {
	return []string{
		"nrSegments",
		"parent",
		"parentIndex",
		"hasChildren",
		"maxGap",
		"keys",
		"values",
		"children",
	}
}

func (x *evictableRangenode) beforeSave() {}

func (x *evictableRangenode) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.nrSegments)
	m.Save(1, &x.parent)
	m.Save(2, &x.parentIndex)
	m.Save(3, &x.hasChildren)
	m.Save(4, &x.maxGap)
	m.Save(5, &x.keys)
	m.Save(6, &x.values)
	m.Save(7, &x.children)
}

func (x *evictableRangenode) afterLoad() {}

func (x *evictableRangenode) StateLoad(m state.Source) {
	m.Load(0, &x.nrSegments)
	m.Load(1, &x.parent)
	m.Load(2, &x.parentIndex)
	m.Load(3, &x.hasChildren)
	m.Load(4, &x.maxGap)
	m.Load(5, &x.keys)
	m.Load(6, &x.values)
	m.Load(7, &x.children)
}

func (x *evictableRangeSegmentDataSlices) StateTypeName() string {
	return "pkg/sentry/pgalloc.evictableRangeSegmentDataSlices"
}

func (x *evictableRangeSegmentDataSlices) StateFields() []string {
	return []string{
		"Start",
		"End",
		"Values",
	}
}

func (x *evictableRangeSegmentDataSlices) beforeSave() {}

func (x *evictableRangeSegmentDataSlices) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Start)
	m.Save(1, &x.End)
	m.Save(2, &x.Values)
}

func (x *evictableRangeSegmentDataSlices) afterLoad() {}

func (x *evictableRangeSegmentDataSlices) StateLoad(m state.Source) {
	m.Load(0, &x.Start)
	m.Load(1, &x.End)
	m.Load(2, &x.Values)
}

func (x *usageInfo) StateTypeName() string {
	return "pkg/sentry/pgalloc.usageInfo"
}

func (x *usageInfo) StateFields() []string {
	return []string{
		"kind",
		"knownCommitted",
		"refs",
	}
}

func (x *usageInfo) beforeSave() {}

func (x *usageInfo) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.kind)
	m.Save(1, &x.knownCommitted)
	m.Save(2, &x.refs)
}

func (x *usageInfo) afterLoad() {}

func (x *usageInfo) StateLoad(m state.Source) {
	m.Load(0, &x.kind)
	m.Load(1, &x.knownCommitted)
	m.Load(2, &x.refs)
}

func (x *reclaimSet) StateTypeName() string {
	return "pkg/sentry/pgalloc.reclaimSet"
}

func (x *reclaimSet) StateFields() []string {
	return []string{
		"root",
	}
}

func (x *reclaimSet) beforeSave() {}

func (x *reclaimSet) StateSave(m state.Sink) {
	x.beforeSave()
	var root *reclaimSegmentDataSlices = x.saveRoot()
	m.SaveValue(0, root)
}

func (x *reclaimSet) afterLoad() {}

func (x *reclaimSet) StateLoad(m state.Source) {
	m.LoadValue(0, new(*reclaimSegmentDataSlices), func(y interface{}) { x.loadRoot(y.(*reclaimSegmentDataSlices)) })
}

func (x *reclaimnode) StateTypeName() string {
	return "pkg/sentry/pgalloc.reclaimnode"
}

func (x *reclaimnode) StateFields() []string {
	return []string{
		"nrSegments",
		"parent",
		"parentIndex",
		"hasChildren",
		"maxGap",
		"keys",
		"values",
		"children",
	}
}

func (x *reclaimnode) beforeSave() {}

func (x *reclaimnode) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.nrSegments)
	m.Save(1, &x.parent)
	m.Save(2, &x.parentIndex)
	m.Save(3, &x.hasChildren)
	m.Save(4, &x.maxGap)
	m.Save(5, &x.keys)
	m.Save(6, &x.values)
	m.Save(7, &x.children)
}

func (x *reclaimnode) afterLoad() {}

func (x *reclaimnode) StateLoad(m state.Source) {
	m.Load(0, &x.nrSegments)
	m.Load(1, &x.parent)
	m.Load(2, &x.parentIndex)
	m.Load(3, &x.hasChildren)
	m.Load(4, &x.maxGap)
	m.Load(5, &x.keys)
	m.Load(6, &x.values)
	m.Load(7, &x.children)
}

func (x *reclaimSegmentDataSlices) StateTypeName() string {
	return "pkg/sentry/pgalloc.reclaimSegmentDataSlices"
}

func (x *reclaimSegmentDataSlices) StateFields() []string {
	return []string{
		"Start",
		"End",
		"Values",
	}
}

func (x *reclaimSegmentDataSlices) beforeSave() {}

func (x *reclaimSegmentDataSlices) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Start)
	m.Save(1, &x.End)
	m.Save(2, &x.Values)
}

func (x *reclaimSegmentDataSlices) afterLoad() {}

func (x *reclaimSegmentDataSlices) StateLoad(m state.Source) {
	m.Load(0, &x.Start)
	m.Load(1, &x.End)
	m.Load(2, &x.Values)
}

func (x *usageSet) StateTypeName() string {
	return "pkg/sentry/pgalloc.usageSet"
}

func (x *usageSet) StateFields() []string {
	return []string{
		"root",
	}
}

func (x *usageSet) beforeSave() {}

func (x *usageSet) StateSave(m state.Sink) {
	x.beforeSave()
	var root *usageSegmentDataSlices = x.saveRoot()
	m.SaveValue(0, root)
}

func (x *usageSet) afterLoad() {}

func (x *usageSet) StateLoad(m state.Source) {
	m.LoadValue(0, new(*usageSegmentDataSlices), func(y interface{}) { x.loadRoot(y.(*usageSegmentDataSlices)) })
}

func (x *usagenode) StateTypeName() string {
	return "pkg/sentry/pgalloc.usagenode"
}

func (x *usagenode) StateFields() []string {
	return []string{
		"nrSegments",
		"parent",
		"parentIndex",
		"hasChildren",
		"maxGap",
		"keys",
		"values",
		"children",
	}
}

func (x *usagenode) beforeSave() {}

func (x *usagenode) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.nrSegments)
	m.Save(1, &x.parent)
	m.Save(2, &x.parentIndex)
	m.Save(3, &x.hasChildren)
	m.Save(4, &x.maxGap)
	m.Save(5, &x.keys)
	m.Save(6, &x.values)
	m.Save(7, &x.children)
}

func (x *usagenode) afterLoad() {}

func (x *usagenode) StateLoad(m state.Source) {
	m.Load(0, &x.nrSegments)
	m.Load(1, &x.parent)
	m.Load(2, &x.parentIndex)
	m.Load(3, &x.hasChildren)
	m.Load(4, &x.maxGap)
	m.Load(5, &x.keys)
	m.Load(6, &x.values)
	m.Load(7, &x.children)
}

func (x *usageSegmentDataSlices) StateTypeName() string {
	return "pkg/sentry/pgalloc.usageSegmentDataSlices"
}

func (x *usageSegmentDataSlices) StateFields() []string {
	return []string{
		"Start",
		"End",
		"Values",
	}
}

func (x *usageSegmentDataSlices) beforeSave() {}

func (x *usageSegmentDataSlices) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Start)
	m.Save(1, &x.End)
	m.Save(2, &x.Values)
}

func (x *usageSegmentDataSlices) afterLoad() {}

func (x *usageSegmentDataSlices) StateLoad(m state.Source) {
	m.Load(0, &x.Start)
	m.Load(1, &x.End)
	m.Load(2, &x.Values)
}

func init() {
	state.Register((*EvictableRange)(nil))
	state.Register((*evictableRangeSet)(nil))
	state.Register((*evictableRangenode)(nil))
	state.Register((*evictableRangeSegmentDataSlices)(nil))
	state.Register((*usageInfo)(nil))
	state.Register((*reclaimSet)(nil))
	state.Register((*reclaimnode)(nil))
	state.Register((*reclaimSegmentDataSlices)(nil))
	state.Register((*usageSet)(nil))
	state.Register((*usagenode)(nil))
	state.Register((*usageSegmentDataSlices)(nil))
}