// automatically generated by stateify.

package kernel

import (
	"gvisor.dev/gvisor/pkg/bpf"
	"gvisor.dev/gvisor/pkg/sentry/device"
	"gvisor.dev/gvisor/pkg/state"
	"gvisor.dev/gvisor/pkg/tcpip"
)

func (x *abstractEndpoint) StateTypeName() string {
	return "pkg/sentry/kernel.abstractEndpoint"
}

func (x *abstractEndpoint) StateFields() []string {
	return []string{
		"ep",
		"socket",
		"name",
		"ns",
	}
}

func (x *abstractEndpoint) beforeSave() {}

func (x *abstractEndpoint) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.ep)
	m.Save(1, &x.socket)
	m.Save(2, &x.name)
	m.Save(3, &x.ns)
}

func (x *abstractEndpoint) afterLoad() {}

func (x *abstractEndpoint) StateLoad(m state.Source) {
	m.Load(0, &x.ep)
	m.Load(1, &x.socket)
	m.Load(2, &x.name)
	m.Load(3, &x.ns)
}

func (x *AbstractSocketNamespace) StateTypeName() string {
	return "pkg/sentry/kernel.AbstractSocketNamespace"
}

func (x *AbstractSocketNamespace) StateFields() []string {
	return []string{
		"endpoints",
	}
}

func (x *AbstractSocketNamespace) beforeSave() {}

func (x *AbstractSocketNamespace) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.endpoints)
}

func (x *AbstractSocketNamespace) afterLoad() {}

func (x *AbstractSocketNamespace) StateLoad(m state.Source) {
	m.Load(0, &x.endpoints)
}

func (x *FDFlags) StateTypeName() string {
	return "pkg/sentry/kernel.FDFlags"
}

func (x *FDFlags) StateFields() []string {
	return []string{
		"CloseOnExec",
	}
}

func (x *FDFlags) beforeSave() {}

func (x *FDFlags) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.CloseOnExec)
}

func (x *FDFlags) afterLoad() {}

func (x *FDFlags) StateLoad(m state.Source) {
	m.Load(0, &x.CloseOnExec)
}

func (x *descriptor) StateTypeName() string {
	return "pkg/sentry/kernel.descriptor"
}

func (x *descriptor) StateFields() []string {
	return []string{
		"file",
		"fileVFS2",
		"flags",
	}
}

func (x *descriptor) beforeSave() {}

func (x *descriptor) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.file)
	m.Save(1, &x.fileVFS2)
	m.Save(2, &x.flags)
}

func (x *descriptor) afterLoad() {}

func (x *descriptor) StateLoad(m state.Source) {
	m.Load(0, &x.file)
	m.Load(1, &x.fileVFS2)
	m.Load(2, &x.flags)
}

func (x *FDTable) StateTypeName() string {
	return "pkg/sentry/kernel.FDTable"
}

func (x *FDTable) StateFields() []string {
	return []string{
		"AtomicRefCount",
		"k",
		"next",
		"used",
		"descriptorTable",
	}
}

func (x *FDTable) beforeSave() {}

func (x *FDTable) StateSave(m state.Sink) {
	x.beforeSave()
	var descriptorTable map[int32]descriptor = x.saveDescriptorTable()
	m.SaveValue(4, descriptorTable)
	m.Save(0, &x.AtomicRefCount)
	m.Save(1, &x.k)
	m.Save(2, &x.next)
	m.Save(3, &x.used)
}

func (x *FDTable) afterLoad() {}

func (x *FDTable) StateLoad(m state.Source) {
	m.Load(0, &x.AtomicRefCount)
	m.Load(1, &x.k)
	m.Load(2, &x.next)
	m.Load(3, &x.used)
	m.LoadValue(4, new(map[int32]descriptor), func(y interface{}) { x.loadDescriptorTable(y.(map[int32]descriptor)) })
}

func (x *FSContext) StateTypeName() string {
	return "pkg/sentry/kernel.FSContext"
}

func (x *FSContext) StateFields() []string {
	return []string{
		"AtomicRefCount",
		"root",
		"rootVFS2",
		"cwd",
		"cwdVFS2",
		"umask",
	}
}

func (x *FSContext) beforeSave() {}

func (x *FSContext) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.AtomicRefCount)
	m.Save(1, &x.root)
	m.Save(2, &x.rootVFS2)
	m.Save(3, &x.cwd)
	m.Save(4, &x.cwdVFS2)
	m.Save(5, &x.umask)
}

func (x *FSContext) afterLoad() {}

func (x *FSContext) StateLoad(m state.Source) {
	m.Load(0, &x.AtomicRefCount)
	m.Load(1, &x.root)
	m.Load(2, &x.rootVFS2)
	m.Load(3, &x.cwd)
	m.Load(4, &x.cwdVFS2)
	m.Load(5, &x.umask)
}

func (x *IPCNamespace) StateTypeName() string {
	return "pkg/sentry/kernel.IPCNamespace"
}

func (x *IPCNamespace) StateFields() []string {
	return []string{
		"userNS",
		"semaphores",
		"shms",
	}
}

func (x *IPCNamespace) beforeSave() {}

func (x *IPCNamespace) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.userNS)
	m.Save(1, &x.semaphores)
	m.Save(2, &x.shms)
}

func (x *IPCNamespace) afterLoad() {}

func (x *IPCNamespace) StateLoad(m state.Source) {
	m.Load(0, &x.userNS)
	m.Load(1, &x.semaphores)
	m.Load(2, &x.shms)
}

func (x *Kernel) StateTypeName() string {
	return "pkg/sentry/kernel.Kernel"
}

func (x *Kernel) StateFields() []string {
	return []string{
		"featureSet",
		"timekeeper",
		"tasks",
		"rootUserNamespace",
		"rootNetworkNamespace",
		"applicationCores",
		"useHostCores",
		"extraAuxv",
		"vdso",
		"rootUTSNamespace",
		"rootIPCNamespace",
		"rootAbstractSocketNamespace",
		"futexes",
		"globalInit",
		"realtimeClock",
		"monotonicClock",
		"syslog",
		"runningTasks",
		"cpuClock",
		"cpuClockTickerDisabled",
		"cpuClockTickerSetting",
		"uniqueID",
		"nextInotifyCookie",
		"netlinkPorts",
		"danglingEndpoints",
		"sockets",
		"nextSocketEntry",
		"deviceRegistry",
		"DirentCacheLimiter",
		"SpecialOpts",
		"vfs",
		"hostMount",
		"pipeMount",
		"shmMount",
		"socketMount",
		"SleepForAddressSpaceActivation",
	}
}

func (x *Kernel) beforeSave() {}

func (x *Kernel) StateSave(m state.Sink) {
	x.beforeSave()
	var danglingEndpoints []tcpip.Endpoint = x.saveDanglingEndpoints()
	m.SaveValue(24, danglingEndpoints)
	var deviceRegistry *device.Registry = x.saveDeviceRegistry()
	m.SaveValue(27, deviceRegistry)
	m.Save(0, &x.featureSet)
	m.Save(1, &x.timekeeper)
	m.Save(2, &x.tasks)
	m.Save(3, &x.rootUserNamespace)
	m.Save(4, &x.rootNetworkNamespace)
	m.Save(5, &x.applicationCores)
	m.Save(6, &x.useHostCores)
	m.Save(7, &x.extraAuxv)
	m.Save(8, &x.vdso)
	m.Save(9, &x.rootUTSNamespace)
	m.Save(10, &x.rootIPCNamespace)
	m.Save(11, &x.rootAbstractSocketNamespace)
	m.Save(12, &x.futexes)
	m.Save(13, &x.globalInit)
	m.Save(14, &x.realtimeClock)
	m.Save(15, &x.monotonicClock)
	m.Save(16, &x.syslog)
	m.Save(17, &x.runningTasks)
	m.Save(18, &x.cpuClock)
	m.Save(19, &x.cpuClockTickerDisabled)
	m.Save(20, &x.cpuClockTickerSetting)
	m.Save(21, &x.uniqueID)
	m.Save(22, &x.nextInotifyCookie)
	m.Save(23, &x.netlinkPorts)
	m.Save(25, &x.sockets)
	m.Save(26, &x.nextSocketEntry)
	m.Save(28, &x.DirentCacheLimiter)
	m.Save(29, &x.SpecialOpts)
	m.Save(30, &x.vfs)
	m.Save(31, &x.hostMount)
	m.Save(32, &x.pipeMount)
	m.Save(33, &x.shmMount)
	m.Save(34, &x.socketMount)
	m.Save(35, &x.SleepForAddressSpaceActivation)
}

func (x *Kernel) afterLoad() {}

func (x *Kernel) StateLoad(m state.Source) {
	m.Load(0, &x.featureSet)
	m.Load(1, &x.timekeeper)
	m.Load(2, &x.tasks)
	m.Load(3, &x.rootUserNamespace)
	m.Load(4, &x.rootNetworkNamespace)
	m.Load(5, &x.applicationCores)
	m.Load(6, &x.useHostCores)
	m.Load(7, &x.extraAuxv)
	m.Load(8, &x.vdso)
	m.Load(9, &x.rootUTSNamespace)
	m.Load(10, &x.rootIPCNamespace)
	m.Load(11, &x.rootAbstractSocketNamespace)
	m.Load(12, &x.futexes)
	m.Load(13, &x.globalInit)
	m.Load(14, &x.realtimeClock)
	m.Load(15, &x.monotonicClock)
	m.Load(16, &x.syslog)
	m.Load(17, &x.runningTasks)
	m.Load(18, &x.cpuClock)
	m.Load(19, &x.cpuClockTickerDisabled)
	m.Load(20, &x.cpuClockTickerSetting)
	m.Load(21, &x.uniqueID)
	m.Load(22, &x.nextInotifyCookie)
	m.Load(23, &x.netlinkPorts)
	m.Load(25, &x.sockets)
	m.Load(26, &x.nextSocketEntry)
	m.Load(28, &x.DirentCacheLimiter)
	m.Load(29, &x.SpecialOpts)
	m.Load(30, &x.vfs)
	m.Load(31, &x.hostMount)
	m.Load(32, &x.pipeMount)
	m.Load(33, &x.shmMount)
	m.Load(34, &x.socketMount)
	m.Load(35, &x.SleepForAddressSpaceActivation)
	m.LoadValue(24, new([]tcpip.Endpoint), func(y interface{}) { x.loadDanglingEndpoints(y.([]tcpip.Endpoint)) })
	m.LoadValue(27, new(*device.Registry), func(y interface{}) { x.loadDeviceRegistry(y.(*device.Registry)) })
}

func (x *SocketEntry) StateTypeName() string {
	return "pkg/sentry/kernel.SocketEntry"
}

func (x *SocketEntry) StateFields() []string {
	return []string{
		"socketEntry",
		"k",
		"Sock",
		"SockVFS2",
		"ID",
	}
}

func (x *SocketEntry) beforeSave() {}

func (x *SocketEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.socketEntry)
	m.Save(1, &x.k)
	m.Save(2, &x.Sock)
	m.Save(3, &x.SockVFS2)
	m.Save(4, &x.ID)
}

func (x *SocketEntry) afterLoad() {}

func (x *SocketEntry) StateLoad(m state.Source) {
	m.Load(0, &x.socketEntry)
	m.Load(1, &x.k)
	m.Load(2, &x.Sock)
	m.Load(3, &x.SockVFS2)
	m.Load(4, &x.ID)
}

func (x *pendingSignals) StateTypeName() string {
	return "pkg/sentry/kernel.pendingSignals"
}

func (x *pendingSignals) StateFields() []string {
	return []string{
		"signals",
	}
}

func (x *pendingSignals) beforeSave() {}

func (x *pendingSignals) StateSave(m state.Sink) {
	x.beforeSave()
	var signals []savedPendingSignal = x.saveSignals()
	m.SaveValue(0, signals)
}

func (x *pendingSignals) afterLoad() {}

func (x *pendingSignals) StateLoad(m state.Source) {
	m.LoadValue(0, new([]savedPendingSignal), func(y interface{}) { x.loadSignals(y.([]savedPendingSignal)) })
}

func (x *pendingSignalQueue) StateTypeName() string {
	return "pkg/sentry/kernel.pendingSignalQueue"
}

func (x *pendingSignalQueue) StateFields() []string {
	return []string{
		"pendingSignalList",
		"length",
	}
}

func (x *pendingSignalQueue) beforeSave() {}

func (x *pendingSignalQueue) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.pendingSignalList)
	m.Save(1, &x.length)
}

func (x *pendingSignalQueue) afterLoad() {}

func (x *pendingSignalQueue) StateLoad(m state.Source) {
	m.Load(0, &x.pendingSignalList)
	m.Load(1, &x.length)
}

func (x *pendingSignal) StateTypeName() string {
	return "pkg/sentry/kernel.pendingSignal"
}

func (x *pendingSignal) StateFields() []string {
	return []string{
		"pendingSignalEntry",
		"SignalInfo",
		"timer",
	}
}

func (x *pendingSignal) beforeSave() {}

func (x *pendingSignal) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.pendingSignalEntry)
	m.Save(1, &x.SignalInfo)
	m.Save(2, &x.timer)
}

func (x *pendingSignal) afterLoad() {}

func (x *pendingSignal) StateLoad(m state.Source) {
	m.Load(0, &x.pendingSignalEntry)
	m.Load(1, &x.SignalInfo)
	m.Load(2, &x.timer)
}

func (x *pendingSignalList) StateTypeName() string {
	return "pkg/sentry/kernel.pendingSignalList"
}

func (x *pendingSignalList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (x *pendingSignalList) beforeSave() {}

func (x *pendingSignalList) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.head)
	m.Save(1, &x.tail)
}

func (x *pendingSignalList) afterLoad() {}

func (x *pendingSignalList) StateLoad(m state.Source) {
	m.Load(0, &x.head)
	m.Load(1, &x.tail)
}

func (x *pendingSignalEntry) StateTypeName() string {
	return "pkg/sentry/kernel.pendingSignalEntry"
}

func (x *pendingSignalEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (x *pendingSignalEntry) beforeSave() {}

func (x *pendingSignalEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.next)
	m.Save(1, &x.prev)
}

func (x *pendingSignalEntry) afterLoad() {}

func (x *pendingSignalEntry) StateLoad(m state.Source) {
	m.Load(0, &x.next)
	m.Load(1, &x.prev)
}

func (x *savedPendingSignal) StateTypeName() string {
	return "pkg/sentry/kernel.savedPendingSignal"
}

func (x *savedPendingSignal) StateFields() []string {
	return []string{
		"si",
		"timer",
	}
}

func (x *savedPendingSignal) beforeSave() {}

func (x *savedPendingSignal) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.si)
	m.Save(1, &x.timer)
}

func (x *savedPendingSignal) afterLoad() {}

func (x *savedPendingSignal) StateLoad(m state.Source) {
	m.Load(0, &x.si)
	m.Load(1, &x.timer)
}

func (x *IntervalTimer) StateTypeName() string {
	return "pkg/sentry/kernel.IntervalTimer"
}

func (x *IntervalTimer) StateFields() []string {
	return []string{
		"timer",
		"target",
		"signo",
		"id",
		"sigval",
		"group",
		"sigpending",
		"sigorphan",
		"overrunCur",
		"overrunLast",
	}
}

func (x *IntervalTimer) beforeSave() {}

func (x *IntervalTimer) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.timer)
	m.Save(1, &x.target)
	m.Save(2, &x.signo)
	m.Save(3, &x.id)
	m.Save(4, &x.sigval)
	m.Save(5, &x.group)
	m.Save(6, &x.sigpending)
	m.Save(7, &x.sigorphan)
	m.Save(8, &x.overrunCur)
	m.Save(9, &x.overrunLast)
}

func (x *IntervalTimer) afterLoad() {}

func (x *IntervalTimer) StateLoad(m state.Source) {
	m.Load(0, &x.timer)
	m.Load(1, &x.target)
	m.Load(2, &x.signo)
	m.Load(3, &x.id)
	m.Load(4, &x.sigval)
	m.Load(5, &x.group)
	m.Load(6, &x.sigpending)
	m.Load(7, &x.sigorphan)
	m.Load(8, &x.overrunCur)
	m.Load(9, &x.overrunLast)
}

func (x *processGroupList) StateTypeName() string {
	return "pkg/sentry/kernel.processGroupList"
}

func (x *processGroupList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (x *processGroupList) beforeSave() {}

func (x *processGroupList) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.head)
	m.Save(1, &x.tail)
}

func (x *processGroupList) afterLoad() {}

func (x *processGroupList) StateLoad(m state.Source) {
	m.Load(0, &x.head)
	m.Load(1, &x.tail)
}

func (x *processGroupEntry) StateTypeName() string {
	return "pkg/sentry/kernel.processGroupEntry"
}

func (x *processGroupEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (x *processGroupEntry) beforeSave() {}

func (x *processGroupEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.next)
	m.Save(1, &x.prev)
}

func (x *processGroupEntry) afterLoad() {}

func (x *processGroupEntry) StateLoad(m state.Source) {
	m.Load(0, &x.next)
	m.Load(1, &x.prev)
}

func (x *ptraceOptions) StateTypeName() string {
	return "pkg/sentry/kernel.ptraceOptions"
}

func (x *ptraceOptions) StateFields() []string {
	return []string{
		"ExitKill",
		"SysGood",
		"TraceClone",
		"TraceExec",
		"TraceExit",
		"TraceFork",
		"TraceSeccomp",
		"TraceVfork",
		"TraceVforkDone",
	}
}

func (x *ptraceOptions) beforeSave() {}

func (x *ptraceOptions) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.ExitKill)
	m.Save(1, &x.SysGood)
	m.Save(2, &x.TraceClone)
	m.Save(3, &x.TraceExec)
	m.Save(4, &x.TraceExit)
	m.Save(5, &x.TraceFork)
	m.Save(6, &x.TraceSeccomp)
	m.Save(7, &x.TraceVfork)
	m.Save(8, &x.TraceVforkDone)
}

func (x *ptraceOptions) afterLoad() {}

func (x *ptraceOptions) StateLoad(m state.Source) {
	m.Load(0, &x.ExitKill)
	m.Load(1, &x.SysGood)
	m.Load(2, &x.TraceClone)
	m.Load(3, &x.TraceExec)
	m.Load(4, &x.TraceExit)
	m.Load(5, &x.TraceFork)
	m.Load(6, &x.TraceSeccomp)
	m.Load(7, &x.TraceVfork)
	m.Load(8, &x.TraceVforkDone)
}

func (x *ptraceStop) StateTypeName() string {
	return "pkg/sentry/kernel.ptraceStop"
}

func (x *ptraceStop) StateFields() []string {
	return []string{
		"frozen",
		"listen",
	}
}

func (x *ptraceStop) beforeSave() {}

func (x *ptraceStop) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.frozen)
	m.Save(1, &x.listen)
}

func (x *ptraceStop) afterLoad() {}

func (x *ptraceStop) StateLoad(m state.Source) {
	m.Load(0, &x.frozen)
	m.Load(1, &x.listen)
}

func (x *OldRSeqCriticalRegion) StateTypeName() string {
	return "pkg/sentry/kernel.OldRSeqCriticalRegion"
}

func (x *OldRSeqCriticalRegion) StateFields() []string {
	return []string{
		"CriticalSection",
		"Restart",
	}
}

func (x *OldRSeqCriticalRegion) beforeSave() {}

func (x *OldRSeqCriticalRegion) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.CriticalSection)
	m.Save(1, &x.Restart)
}

func (x *OldRSeqCriticalRegion) afterLoad() {}

func (x *OldRSeqCriticalRegion) StateLoad(m state.Source) {
	m.Load(0, &x.CriticalSection)
	m.Load(1, &x.Restart)
}

func (x *sessionList) StateTypeName() string {
	return "pkg/sentry/kernel.sessionList"
}

func (x *sessionList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (x *sessionList) beforeSave() {}

func (x *sessionList) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.head)
	m.Save(1, &x.tail)
}

func (x *sessionList) afterLoad() {}

func (x *sessionList) StateLoad(m state.Source) {
	m.Load(0, &x.head)
	m.Load(1, &x.tail)
}

func (x *sessionEntry) StateTypeName() string {
	return "pkg/sentry/kernel.sessionEntry"
}

func (x *sessionEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (x *sessionEntry) beforeSave() {}

func (x *sessionEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.next)
	m.Save(1, &x.prev)
}

func (x *sessionEntry) afterLoad() {}

func (x *sessionEntry) StateLoad(m state.Source) {
	m.Load(0, &x.next)
	m.Load(1, &x.prev)
}

func (x *Session) StateTypeName() string {
	return "pkg/sentry/kernel.Session"
}

func (x *Session) StateFields() []string {
	return []string{
		"refs",
		"leader",
		"id",
		"foreground",
		"processGroups",
		"sessionEntry",
	}
}

func (x *Session) beforeSave() {}

func (x *Session) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.refs)
	m.Save(1, &x.leader)
	m.Save(2, &x.id)
	m.Save(3, &x.foreground)
	m.Save(4, &x.processGroups)
	m.Save(5, &x.sessionEntry)
}

func (x *Session) afterLoad() {}

func (x *Session) StateLoad(m state.Source) {
	m.Load(0, &x.refs)
	m.Load(1, &x.leader)
	m.Load(2, &x.id)
	m.Load(3, &x.foreground)
	m.Load(4, &x.processGroups)
	m.Load(5, &x.sessionEntry)
}

func (x *ProcessGroup) StateTypeName() string {
	return "pkg/sentry/kernel.ProcessGroup"
}

func (x *ProcessGroup) StateFields() []string {
	return []string{
		"refs",
		"originator",
		"id",
		"session",
		"ancestors",
		"processGroupEntry",
	}
}

func (x *ProcessGroup) beforeSave() {}

func (x *ProcessGroup) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.refs)
	m.Save(1, &x.originator)
	m.Save(2, &x.id)
	m.Save(3, &x.session)
	m.Save(4, &x.ancestors)
	m.Save(5, &x.processGroupEntry)
}

func (x *ProcessGroup) afterLoad() {}

func (x *ProcessGroup) StateLoad(m state.Source) {
	m.Load(0, &x.refs)
	m.Load(1, &x.originator)
	m.Load(2, &x.id)
	m.Load(3, &x.session)
	m.Load(4, &x.ancestors)
	m.Load(5, &x.processGroupEntry)
}

func (x *SignalHandlers) StateTypeName() string {
	return "pkg/sentry/kernel.SignalHandlers"
}

func (x *SignalHandlers) StateFields() []string {
	return []string{
		"actions",
	}
}

func (x *SignalHandlers) beforeSave() {}

func (x *SignalHandlers) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.actions)
}

func (x *SignalHandlers) afterLoad() {}

func (x *SignalHandlers) StateLoad(m state.Source) {
	m.Load(0, &x.actions)
}

func (x *socketList) StateTypeName() string {
	return "pkg/sentry/kernel.socketList"
}

func (x *socketList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (x *socketList) beforeSave() {}

func (x *socketList) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.head)
	m.Save(1, &x.tail)
}

func (x *socketList) afterLoad() {}

func (x *socketList) StateLoad(m state.Source) {
	m.Load(0, &x.head)
	m.Load(1, &x.tail)
}

func (x *socketEntry) StateTypeName() string {
	return "pkg/sentry/kernel.socketEntry"
}

func (x *socketEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (x *socketEntry) beforeSave() {}

func (x *socketEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.next)
	m.Save(1, &x.prev)
}

func (x *socketEntry) afterLoad() {}

func (x *socketEntry) StateLoad(m state.Source) {
	m.Load(0, &x.next)
	m.Load(1, &x.prev)
}

func (x *syscallTableInfo) StateTypeName() string {
	return "pkg/sentry/kernel.syscallTableInfo"
}

func (x *syscallTableInfo) StateFields() []string {
	return []string{
		"OS",
		"Arch",
	}
}

func (x *syscallTableInfo) beforeSave() {}

func (x *syscallTableInfo) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.OS)
	m.Save(1, &x.Arch)
}

func (x *syscallTableInfo) afterLoad() {}

func (x *syscallTableInfo) StateLoad(m state.Source) {
	m.Load(0, &x.OS)
	m.Load(1, &x.Arch)
}

func (x *syslog) StateTypeName() string {
	return "pkg/sentry/kernel.syslog"
}

func (x *syslog) StateFields() []string {
	return []string{
		"msg",
	}
}

func (x *syslog) beforeSave() {}

func (x *syslog) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.msg)
}

func (x *syslog) afterLoad() {}

func (x *syslog) StateLoad(m state.Source) {
	m.Load(0, &x.msg)
}

func (x *Task) StateTypeName() string {
	return "pkg/sentry/kernel.Task"
}

func (x *Task) StateFields() []string {
	return []string{
		"taskNode",
		"runState",
		"taskWorkCount",
		"taskWork",
		"haveSyscallReturn",
		"gosched",
		"yieldCount",
		"pendingSignals",
		"signalMask",
		"realSignalMask",
		"haveSavedSignalMask",
		"savedSignalMask",
		"signalStack",
		"groupStopPending",
		"groupStopAcknowledged",
		"trapStopPending",
		"trapNotifyPending",
		"stop",
		"exitStatus",
		"syscallRestartBlock",
		"k",
		"containerID",
		"tc",
		"fsContext",
		"fdTable",
		"vforkParent",
		"exitState",
		"exitTracerNotified",
		"exitTracerAcked",
		"exitParentNotified",
		"exitParentAcked",
		"ptraceTracer",
		"ptraceTracees",
		"ptraceSeized",
		"ptraceOpts",
		"ptraceSyscallMode",
		"ptraceSinglestep",
		"ptraceCode",
		"ptraceSiginfo",
		"ptraceEventMsg",
		"ioUsage",
		"creds",
		"utsns",
		"ipcns",
		"abstractSockets",
		"mountNamespaceVFS2",
		"parentDeathSignal",
		"syscallFilters",
		"cleartid",
		"allowedCPUMask",
		"cpu",
		"niceness",
		"numaPolicy",
		"numaNodeMask",
		"netns",
		"rseqCPU",
		"oldRSeqCPUAddr",
		"rseqAddr",
		"rseqSignature",
		"robustList",
		"startTime",
	}
}

func (x *Task) beforeSave() {}

func (x *Task) StateSave(m state.Sink) {
	x.beforeSave()
	if !state.IsZeroValue(&x.signalQueue) {
		state.Failf("signalQueue is %#v, expected zero", &x.signalQueue)
	}
	var ptraceTracer *Task = x.savePtraceTracer()
	m.SaveValue(31, ptraceTracer)
	var syscallFilters []bpf.Program = x.saveSyscallFilters()
	m.SaveValue(47, syscallFilters)
	m.Save(0, &x.taskNode)
	m.Save(1, &x.runState)
	m.Save(2, &x.taskWorkCount)
	m.Save(3, &x.taskWork)
	m.Save(4, &x.haveSyscallReturn)
	m.Save(5, &x.gosched)
	m.Save(6, &x.yieldCount)
	m.Save(7, &x.pendingSignals)
	m.Save(8, &x.signalMask)
	m.Save(9, &x.realSignalMask)
	m.Save(10, &x.haveSavedSignalMask)
	m.Save(11, &x.savedSignalMask)
	m.Save(12, &x.signalStack)
	m.Save(13, &x.groupStopPending)
	m.Save(14, &x.groupStopAcknowledged)
	m.Save(15, &x.trapStopPending)
	m.Save(16, &x.trapNotifyPending)
	m.Save(17, &x.stop)
	m.Save(18, &x.exitStatus)
	m.Save(19, &x.syscallRestartBlock)
	m.Save(20, &x.k)
	m.Save(21, &x.containerID)
	m.Save(22, &x.tc)
	m.Save(23, &x.fsContext)
	m.Save(24, &x.fdTable)
	m.Save(25, &x.vforkParent)
	m.Save(26, &x.exitState)
	m.Save(27, &x.exitTracerNotified)
	m.Save(28, &x.exitTracerAcked)
	m.Save(29, &x.exitParentNotified)
	m.Save(30, &x.exitParentAcked)
	m.Save(32, &x.ptraceTracees)
	m.Save(33, &x.ptraceSeized)
	m.Save(34, &x.ptraceOpts)
	m.Save(35, &x.ptraceSyscallMode)
	m.Save(36, &x.ptraceSinglestep)
	m.Save(37, &x.ptraceCode)
	m.Save(38, &x.ptraceSiginfo)
	m.Save(39, &x.ptraceEventMsg)
	m.Save(40, &x.ioUsage)
	m.Save(41, &x.creds)
	m.Save(42, &x.utsns)
	m.Save(43, &x.ipcns)
	m.Save(44, &x.abstractSockets)
	m.Save(45, &x.mountNamespaceVFS2)
	m.Save(46, &x.parentDeathSignal)
	m.Save(48, &x.cleartid)
	m.Save(49, &x.allowedCPUMask)
	m.Save(50, &x.cpu)
	m.Save(51, &x.niceness)
	m.Save(52, &x.numaPolicy)
	m.Save(53, &x.numaNodeMask)
	m.Save(54, &x.netns)
	m.Save(55, &x.rseqCPU)
	m.Save(56, &x.oldRSeqCPUAddr)
	m.Save(57, &x.rseqAddr)
	m.Save(58, &x.rseqSignature)
	m.Save(59, &x.robustList)
	m.Save(60, &x.startTime)
}

func (x *Task) StateLoad(m state.Source) {
	m.Load(0, &x.taskNode)
	m.Load(1, &x.runState)
	m.Load(2, &x.taskWorkCount)
	m.Load(3, &x.taskWork)
	m.Load(4, &x.haveSyscallReturn)
	m.Load(5, &x.gosched)
	m.Load(6, &x.yieldCount)
	m.Load(7, &x.pendingSignals)
	m.Load(8, &x.signalMask)
	m.Load(9, &x.realSignalMask)
	m.Load(10, &x.haveSavedSignalMask)
	m.Load(11, &x.savedSignalMask)
	m.Load(12, &x.signalStack)
	m.Load(13, &x.groupStopPending)
	m.Load(14, &x.groupStopAcknowledged)
	m.Load(15, &x.trapStopPending)
	m.Load(16, &x.trapNotifyPending)
	m.Load(17, &x.stop)
	m.Load(18, &x.exitStatus)
	m.Load(19, &x.syscallRestartBlock)
	m.Load(20, &x.k)
	m.Load(21, &x.containerID)
	m.Load(22, &x.tc)
	m.Load(23, &x.fsContext)
	m.Load(24, &x.fdTable)
	m.Load(25, &x.vforkParent)
	m.Load(26, &x.exitState)
	m.Load(27, &x.exitTracerNotified)
	m.Load(28, &x.exitTracerAcked)
	m.Load(29, &x.exitParentNotified)
	m.Load(30, &x.exitParentAcked)
	m.Load(32, &x.ptraceTracees)
	m.Load(33, &x.ptraceSeized)
	m.Load(34, &x.ptraceOpts)
	m.Load(35, &x.ptraceSyscallMode)
	m.Load(36, &x.ptraceSinglestep)
	m.Load(37, &x.ptraceCode)
	m.Load(38, &x.ptraceSiginfo)
	m.Load(39, &x.ptraceEventMsg)
	m.Load(40, &x.ioUsage)
	m.Load(41, &x.creds)
	m.Load(42, &x.utsns)
	m.Load(43, &x.ipcns)
	m.Load(44, &x.abstractSockets)
	m.Load(45, &x.mountNamespaceVFS2)
	m.Load(46, &x.parentDeathSignal)
	m.Load(48, &x.cleartid)
	m.Load(49, &x.allowedCPUMask)
	m.Load(50, &x.cpu)
	m.Load(51, &x.niceness)
	m.Load(52, &x.numaPolicy)
	m.Load(53, &x.numaNodeMask)
	m.Load(54, &x.netns)
	m.Load(55, &x.rseqCPU)
	m.Load(56, &x.oldRSeqCPUAddr)
	m.Load(57, &x.rseqAddr)
	m.Load(58, &x.rseqSignature)
	m.Load(59, &x.robustList)
	m.Load(60, &x.startTime)
	m.LoadValue(31, new(*Task), func(y interface{}) { x.loadPtraceTracer(y.(*Task)) })
	m.LoadValue(47, new([]bpf.Program), func(y interface{}) { x.loadSyscallFilters(y.([]bpf.Program)) })
	m.AfterLoad(x.afterLoad)
}

func (x *runSyscallAfterPtraceEventClone) StateTypeName() string {
	return "pkg/sentry/kernel.runSyscallAfterPtraceEventClone"
}

func (x *runSyscallAfterPtraceEventClone) StateFields() []string {
	return []string{
		"vforkChild",
		"vforkChildTID",
	}
}

func (x *runSyscallAfterPtraceEventClone) beforeSave() {}

func (x *runSyscallAfterPtraceEventClone) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.vforkChild)
	m.Save(1, &x.vforkChildTID)
}

func (x *runSyscallAfterPtraceEventClone) afterLoad() {}

func (x *runSyscallAfterPtraceEventClone) StateLoad(m state.Source) {
	m.Load(0, &x.vforkChild)
	m.Load(1, &x.vforkChildTID)
}

func (x *runSyscallAfterVforkStop) StateTypeName() string {
	return "pkg/sentry/kernel.runSyscallAfterVforkStop"
}

func (x *runSyscallAfterVforkStop) StateFields() []string {
	return []string{
		"childTID",
	}
}

func (x *runSyscallAfterVforkStop) beforeSave() {}

func (x *runSyscallAfterVforkStop) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.childTID)
}

func (x *runSyscallAfterVforkStop) afterLoad() {}

func (x *runSyscallAfterVforkStop) StateLoad(m state.Source) {
	m.Load(0, &x.childTID)
}

func (x *vforkStop) StateTypeName() string {
	return "pkg/sentry/kernel.vforkStop"
}

func (x *vforkStop) StateFields() []string {
	return []string{}
}

func (x *vforkStop) beforeSave() {}

func (x *vforkStop) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *vforkStop) afterLoad() {}

func (x *vforkStop) StateLoad(m state.Source) {
}

func (x *TaskContext) StateTypeName() string {
	return "pkg/sentry/kernel.TaskContext"
}

func (x *TaskContext) StateFields() []string {
	return []string{
		"Name",
		"Arch",
		"MemoryManager",
		"fu",
		"st",
	}
}

func (x *TaskContext) beforeSave() {}

func (x *TaskContext) StateSave(m state.Sink) {
	x.beforeSave()
	var st syscallTableInfo = x.saveSt()
	m.SaveValue(4, st)
	m.Save(0, &x.Name)
	m.Save(1, &x.Arch)
	m.Save(2, &x.MemoryManager)
	m.Save(3, &x.fu)
}

func (x *TaskContext) afterLoad() {}

func (x *TaskContext) StateLoad(m state.Source) {
	m.Load(0, &x.Name)
	m.Load(1, &x.Arch)
	m.Load(2, &x.MemoryManager)
	m.Load(3, &x.fu)
	m.LoadValue(4, new(syscallTableInfo), func(y interface{}) { x.loadSt(y.(syscallTableInfo)) })
}

func (x *execStop) StateTypeName() string {
	return "pkg/sentry/kernel.execStop"
}

func (x *execStop) StateFields() []string {
	return []string{}
}

func (x *execStop) beforeSave() {}

func (x *execStop) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *execStop) afterLoad() {}

func (x *execStop) StateLoad(m state.Source) {
}

func (x *runSyscallAfterExecStop) StateTypeName() string {
	return "pkg/sentry/kernel.runSyscallAfterExecStop"
}

func (x *runSyscallAfterExecStop) StateFields() []string {
	return []string{
		"tc",
	}
}

func (x *runSyscallAfterExecStop) beforeSave() {}

func (x *runSyscallAfterExecStop) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.tc)
}

func (x *runSyscallAfterExecStop) afterLoad() {}

func (x *runSyscallAfterExecStop) StateLoad(m state.Source) {
	m.Load(0, &x.tc)
}

func (x *ExitStatus) StateTypeName() string {
	return "pkg/sentry/kernel.ExitStatus"
}

func (x *ExitStatus) StateFields() []string {
	return []string{
		"Code",
		"Signo",
	}
}

func (x *ExitStatus) beforeSave() {}

func (x *ExitStatus) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Code)
	m.Save(1, &x.Signo)
}

func (x *ExitStatus) afterLoad() {}

func (x *ExitStatus) StateLoad(m state.Source) {
	m.Load(0, &x.Code)
	m.Load(1, &x.Signo)
}

func (x *runExit) StateTypeName() string {
	return "pkg/sentry/kernel.runExit"
}

func (x *runExit) StateFields() []string {
	return []string{}
}

func (x *runExit) beforeSave() {}

func (x *runExit) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runExit) afterLoad() {}

func (x *runExit) StateLoad(m state.Source) {
}

func (x *runExitMain) StateTypeName() string {
	return "pkg/sentry/kernel.runExitMain"
}

func (x *runExitMain) StateFields() []string {
	return []string{}
}

func (x *runExitMain) beforeSave() {}

func (x *runExitMain) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runExitMain) afterLoad() {}

func (x *runExitMain) StateLoad(m state.Source) {
}

func (x *runExitNotify) StateTypeName() string {
	return "pkg/sentry/kernel.runExitNotify"
}

func (x *runExitNotify) StateFields() []string {
	return []string{}
}

func (x *runExitNotify) beforeSave() {}

func (x *runExitNotify) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runExitNotify) afterLoad() {}

func (x *runExitNotify) StateLoad(m state.Source) {
}

func (x *taskList) StateTypeName() string {
	return "pkg/sentry/kernel.taskList"
}

func (x *taskList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (x *taskList) beforeSave() {}

func (x *taskList) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.head)
	m.Save(1, &x.tail)
}

func (x *taskList) afterLoad() {}

func (x *taskList) StateLoad(m state.Source) {
	m.Load(0, &x.head)
	m.Load(1, &x.tail)
}

func (x *taskEntry) StateTypeName() string {
	return "pkg/sentry/kernel.taskEntry"
}

func (x *taskEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (x *taskEntry) beforeSave() {}

func (x *taskEntry) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.next)
	m.Save(1, &x.prev)
}

func (x *taskEntry) afterLoad() {}

func (x *taskEntry) StateLoad(m state.Source) {
	m.Load(0, &x.next)
	m.Load(1, &x.prev)
}

func (x *runApp) StateTypeName() string {
	return "pkg/sentry/kernel.runApp"
}

func (x *runApp) StateFields() []string {
	return []string{}
}

func (x *runApp) beforeSave() {}

func (x *runApp) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runApp) afterLoad() {}

func (x *runApp) StateLoad(m state.Source) {
}

func (x *TaskGoroutineSchedInfo) StateTypeName() string {
	return "pkg/sentry/kernel.TaskGoroutineSchedInfo"
}

func (x *TaskGoroutineSchedInfo) StateFields() []string {
	return []string{
		"Timestamp",
		"State",
		"UserTicks",
		"SysTicks",
	}
}

func (x *TaskGoroutineSchedInfo) beforeSave() {}

func (x *TaskGoroutineSchedInfo) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Timestamp)
	m.Save(1, &x.State)
	m.Save(2, &x.UserTicks)
	m.Save(3, &x.SysTicks)
}

func (x *TaskGoroutineSchedInfo) afterLoad() {}

func (x *TaskGoroutineSchedInfo) StateLoad(m state.Source) {
	m.Load(0, &x.Timestamp)
	m.Load(1, &x.State)
	m.Load(2, &x.UserTicks)
	m.Load(3, &x.SysTicks)
}

func (x *taskClock) StateTypeName() string {
	return "pkg/sentry/kernel.taskClock"
}

func (x *taskClock) StateFields() []string {
	return []string{
		"t",
		"includeSys",
	}
}

func (x *taskClock) beforeSave() {}

func (x *taskClock) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.t)
	m.Save(1, &x.includeSys)
}

func (x *taskClock) afterLoad() {}

func (x *taskClock) StateLoad(m state.Source) {
	m.Load(0, &x.t)
	m.Load(1, &x.includeSys)
}

func (x *tgClock) StateTypeName() string {
	return "pkg/sentry/kernel.tgClock"
}

func (x *tgClock) StateFields() []string {
	return []string{
		"tg",
		"includeSys",
	}
}

func (x *tgClock) beforeSave() {}

func (x *tgClock) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.tg)
	m.Save(1, &x.includeSys)
}

func (x *tgClock) afterLoad() {}

func (x *tgClock) StateLoad(m state.Source) {
	m.Load(0, &x.tg)
	m.Load(1, &x.includeSys)
}

func (x *groupStop) StateTypeName() string {
	return "pkg/sentry/kernel.groupStop"
}

func (x *groupStop) StateFields() []string {
	return []string{}
}

func (x *groupStop) beforeSave() {}

func (x *groupStop) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *groupStop) afterLoad() {}

func (x *groupStop) StateLoad(m state.Source) {
}

func (x *runInterrupt) StateTypeName() string {
	return "pkg/sentry/kernel.runInterrupt"
}

func (x *runInterrupt) StateFields() []string {
	return []string{}
}

func (x *runInterrupt) beforeSave() {}

func (x *runInterrupt) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runInterrupt) afterLoad() {}

func (x *runInterrupt) StateLoad(m state.Source) {
}

func (x *runInterruptAfterSignalDeliveryStop) StateTypeName() string {
	return "pkg/sentry/kernel.runInterruptAfterSignalDeliveryStop"
}

func (x *runInterruptAfterSignalDeliveryStop) StateFields() []string {
	return []string{}
}

func (x *runInterruptAfterSignalDeliveryStop) beforeSave() {}

func (x *runInterruptAfterSignalDeliveryStop) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runInterruptAfterSignalDeliveryStop) afterLoad() {}

func (x *runInterruptAfterSignalDeliveryStop) StateLoad(m state.Source) {
}

func (x *runSyscallAfterSyscallEnterStop) StateTypeName() string {
	return "pkg/sentry/kernel.runSyscallAfterSyscallEnterStop"
}

func (x *runSyscallAfterSyscallEnterStop) StateFields() []string {
	return []string{}
}

func (x *runSyscallAfterSyscallEnterStop) beforeSave() {}

func (x *runSyscallAfterSyscallEnterStop) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runSyscallAfterSyscallEnterStop) afterLoad() {}

func (x *runSyscallAfterSyscallEnterStop) StateLoad(m state.Source) {
}

func (x *runSyscallAfterSysemuStop) StateTypeName() string {
	return "pkg/sentry/kernel.runSyscallAfterSysemuStop"
}

func (x *runSyscallAfterSysemuStop) StateFields() []string {
	return []string{}
}

func (x *runSyscallAfterSysemuStop) beforeSave() {}

func (x *runSyscallAfterSysemuStop) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runSyscallAfterSysemuStop) afterLoad() {}

func (x *runSyscallAfterSysemuStop) StateLoad(m state.Source) {
}

func (x *runSyscallReinvoke) StateTypeName() string {
	return "pkg/sentry/kernel.runSyscallReinvoke"
}

func (x *runSyscallReinvoke) StateFields() []string {
	return []string{}
}

func (x *runSyscallReinvoke) beforeSave() {}

func (x *runSyscallReinvoke) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runSyscallReinvoke) afterLoad() {}

func (x *runSyscallReinvoke) StateLoad(m state.Source) {
}

func (x *runSyscallExit) StateTypeName() string {
	return "pkg/sentry/kernel.runSyscallExit"
}

func (x *runSyscallExit) StateFields() []string {
	return []string{}
}

func (x *runSyscallExit) beforeSave() {}

func (x *runSyscallExit) StateSave(m state.Sink) {
	x.beforeSave()
}

func (x *runSyscallExit) afterLoad() {}

func (x *runSyscallExit) StateLoad(m state.Source) {
}

func (x *ThreadGroup) StateTypeName() string {
	return "pkg/sentry/kernel.ThreadGroup"
}

func (x *ThreadGroup) StateFields() []string {
	return []string{
		"threadGroupNode",
		"signalHandlers",
		"pendingSignals",
		"groupStopDequeued",
		"groupStopSignal",
		"groupStopPendingCount",
		"groupStopComplete",
		"groupStopWaitable",
		"groupContNotify",
		"groupContInterrupted",
		"groupContWaitable",
		"exiting",
		"exitStatus",
		"terminationSignal",
		"itimerRealTimer",
		"itimerVirtSetting",
		"itimerProfSetting",
		"rlimitCPUSoftSetting",
		"cpuTimersEnabled",
		"timers",
		"nextTimerID",
		"exitedCPUStats",
		"childCPUStats",
		"ioUsage",
		"maxRSS",
		"childMaxRSS",
		"limits",
		"processGroup",
		"execed",
		"oldRSeqCritical",
		"mounts",
		"tty",
		"oomScoreAdj",
	}
}

func (x *ThreadGroup) beforeSave() {}

func (x *ThreadGroup) StateSave(m state.Sink) {
	x.beforeSave()
	var oldRSeqCritical *OldRSeqCriticalRegion = x.saveOldRSeqCritical()
	m.SaveValue(29, oldRSeqCritical)
	m.Save(0, &x.threadGroupNode)
	m.Save(1, &x.signalHandlers)
	m.Save(2, &x.pendingSignals)
	m.Save(3, &x.groupStopDequeued)
	m.Save(4, &x.groupStopSignal)
	m.Save(5, &x.groupStopPendingCount)
	m.Save(6, &x.groupStopComplete)
	m.Save(7, &x.groupStopWaitable)
	m.Save(8, &x.groupContNotify)
	m.Save(9, &x.groupContInterrupted)
	m.Save(10, &x.groupContWaitable)
	m.Save(11, &x.exiting)
	m.Save(12, &x.exitStatus)
	m.Save(13, &x.terminationSignal)
	m.Save(14, &x.itimerRealTimer)
	m.Save(15, &x.itimerVirtSetting)
	m.Save(16, &x.itimerProfSetting)
	m.Save(17, &x.rlimitCPUSoftSetting)
	m.Save(18, &x.cpuTimersEnabled)
	m.Save(19, &x.timers)
	m.Save(20, &x.nextTimerID)
	m.Save(21, &x.exitedCPUStats)
	m.Save(22, &x.childCPUStats)
	m.Save(23, &x.ioUsage)
	m.Save(24, &x.maxRSS)
	m.Save(25, &x.childMaxRSS)
	m.Save(26, &x.limits)
	m.Save(27, &x.processGroup)
	m.Save(28, &x.execed)
	m.Save(30, &x.mounts)
	m.Save(31, &x.tty)
	m.Save(32, &x.oomScoreAdj)
}

func (x *ThreadGroup) afterLoad() {}

func (x *ThreadGroup) StateLoad(m state.Source) {
	m.Load(0, &x.threadGroupNode)
	m.Load(1, &x.signalHandlers)
	m.Load(2, &x.pendingSignals)
	m.Load(3, &x.groupStopDequeued)
	m.Load(4, &x.groupStopSignal)
	m.Load(5, &x.groupStopPendingCount)
	m.Load(6, &x.groupStopComplete)
	m.Load(7, &x.groupStopWaitable)
	m.Load(8, &x.groupContNotify)
	m.Load(9, &x.groupContInterrupted)
	m.Load(10, &x.groupContWaitable)
	m.Load(11, &x.exiting)
	m.Load(12, &x.exitStatus)
	m.Load(13, &x.terminationSignal)
	m.Load(14, &x.itimerRealTimer)
	m.Load(15, &x.itimerVirtSetting)
	m.Load(16, &x.itimerProfSetting)
	m.Load(17, &x.rlimitCPUSoftSetting)
	m.Load(18, &x.cpuTimersEnabled)
	m.Load(19, &x.timers)
	m.Load(20, &x.nextTimerID)
	m.Load(21, &x.exitedCPUStats)
	m.Load(22, &x.childCPUStats)
	m.Load(23, &x.ioUsage)
	m.Load(24, &x.maxRSS)
	m.Load(25, &x.childMaxRSS)
	m.Load(26, &x.limits)
	m.Load(27, &x.processGroup)
	m.Load(28, &x.execed)
	m.Load(30, &x.mounts)
	m.Load(31, &x.tty)
	m.Load(32, &x.oomScoreAdj)
	m.LoadValue(29, new(*OldRSeqCriticalRegion), func(y interface{}) { x.loadOldRSeqCritical(y.(*OldRSeqCriticalRegion)) })
}

func (x *itimerRealListener) StateTypeName() string {
	return "pkg/sentry/kernel.itimerRealListener"
}

func (x *itimerRealListener) StateFields() []string {
	return []string{
		"tg",
	}
}

func (x *itimerRealListener) beforeSave() {}

func (x *itimerRealListener) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.tg)
}

func (x *itimerRealListener) afterLoad() {}

func (x *itimerRealListener) StateLoad(m state.Source) {
	m.Load(0, &x.tg)
}

func (x *TaskSet) StateTypeName() string {
	return "pkg/sentry/kernel.TaskSet"
}

func (x *TaskSet) StateFields() []string {
	return []string{
		"Root",
		"sessions",
	}
}

func (x *TaskSet) beforeSave() {}

func (x *TaskSet) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Root)
	m.Save(1, &x.sessions)
}

func (x *TaskSet) afterLoad() {}

func (x *TaskSet) StateLoad(m state.Source) {
	m.Load(0, &x.Root)
	m.Load(1, &x.sessions)
}

func (x *PIDNamespace) StateTypeName() string {
	return "pkg/sentry/kernel.PIDNamespace"
}

func (x *PIDNamespace) StateFields() []string {
	return []string{
		"owner",
		"parent",
		"userns",
		"last",
		"tasks",
		"tids",
		"tgids",
		"sessions",
		"sids",
		"processGroups",
		"pgids",
		"exiting",
	}
}

func (x *PIDNamespace) beforeSave() {}

func (x *PIDNamespace) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.owner)
	m.Save(1, &x.parent)
	m.Save(2, &x.userns)
	m.Save(3, &x.last)
	m.Save(4, &x.tasks)
	m.Save(5, &x.tids)
	m.Save(6, &x.tgids)
	m.Save(7, &x.sessions)
	m.Save(8, &x.sids)
	m.Save(9, &x.processGroups)
	m.Save(10, &x.pgids)
	m.Save(11, &x.exiting)
}

func (x *PIDNamespace) afterLoad() {}

func (x *PIDNamespace) StateLoad(m state.Source) {
	m.Load(0, &x.owner)
	m.Load(1, &x.parent)
	m.Load(2, &x.userns)
	m.Load(3, &x.last)
	m.Load(4, &x.tasks)
	m.Load(5, &x.tids)
	m.Load(6, &x.tgids)
	m.Load(7, &x.sessions)
	m.Load(8, &x.sids)
	m.Load(9, &x.processGroups)
	m.Load(10, &x.pgids)
	m.Load(11, &x.exiting)
}

func (x *threadGroupNode) StateTypeName() string {
	return "pkg/sentry/kernel.threadGroupNode"
}

func (x *threadGroupNode) StateFields() []string {
	return []string{
		"pidns",
		"leader",
		"execing",
		"tasks",
		"tasksCount",
		"liveTasks",
		"activeTasks",
	}
}

func (x *threadGroupNode) beforeSave() {}

func (x *threadGroupNode) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.pidns)
	m.Save(1, &x.leader)
	m.Save(2, &x.execing)
	m.Save(3, &x.tasks)
	m.Save(4, &x.tasksCount)
	m.Save(5, &x.liveTasks)
	m.Save(6, &x.activeTasks)
}

func (x *threadGroupNode) afterLoad() {}

func (x *threadGroupNode) StateLoad(m state.Source) {
	m.Load(0, &x.pidns)
	m.Load(1, &x.leader)
	m.Load(2, &x.execing)
	m.Load(3, &x.tasks)
	m.Load(4, &x.tasksCount)
	m.Load(5, &x.liveTasks)
	m.Load(6, &x.activeTasks)
}

func (x *taskNode) StateTypeName() string {
	return "pkg/sentry/kernel.taskNode"
}

func (x *taskNode) StateFields() []string {
	return []string{
		"tg",
		"taskEntry",
		"parent",
		"children",
		"childPIDNamespace",
	}
}

func (x *taskNode) beforeSave() {}

func (x *taskNode) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.tg)
	m.Save(1, &x.taskEntry)
	m.Save(2, &x.parent)
	m.Save(3, &x.children)
	m.Save(4, &x.childPIDNamespace)
}

func (x *taskNode) afterLoad() {}

func (x *taskNode) StateLoad(m state.Source) {
	m.LoadWait(0, &x.tg)
	m.Load(1, &x.taskEntry)
	m.Load(2, &x.parent)
	m.Load(3, &x.children)
	m.Load(4, &x.childPIDNamespace)
}

func (x *Timekeeper) StateTypeName() string {
	return "pkg/sentry/kernel.Timekeeper"
}

func (x *Timekeeper) StateFields() []string {
	return []string{
		"bootTime",
		"saveMonotonic",
		"saveRealtime",
		"params",
	}
}

func (x *Timekeeper) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.bootTime)
	m.Save(1, &x.saveMonotonic)
	m.Save(2, &x.saveRealtime)
	m.Save(3, &x.params)
}

func (x *Timekeeper) StateLoad(m state.Source) {
	m.Load(0, &x.bootTime)
	m.Load(1, &x.saveMonotonic)
	m.Load(2, &x.saveRealtime)
	m.Load(3, &x.params)
	m.AfterLoad(x.afterLoad)
}

func (x *timekeeperClock) StateTypeName() string {
	return "pkg/sentry/kernel.timekeeperClock"
}

func (x *timekeeperClock) StateFields() []string {
	return []string{
		"tk",
		"c",
	}
}

func (x *timekeeperClock) beforeSave() {}

func (x *timekeeperClock) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.tk)
	m.Save(1, &x.c)
}

func (x *timekeeperClock) afterLoad() {}

func (x *timekeeperClock) StateLoad(m state.Source) {
	m.Load(0, &x.tk)
	m.Load(1, &x.c)
}

func (x *TTY) StateTypeName() string {
	return "pkg/sentry/kernel.TTY"
}

func (x *TTY) StateFields() []string {
	return []string{
		"Index",
		"tg",
	}
}

func (x *TTY) beforeSave() {}

func (x *TTY) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.Index)
	m.Save(1, &x.tg)
}

func (x *TTY) afterLoad() {}

func (x *TTY) StateLoad(m state.Source) {
	m.Load(0, &x.Index)
	m.Load(1, &x.tg)
}

func (x *UTSNamespace) StateTypeName() string {
	return "pkg/sentry/kernel.UTSNamespace"
}

func (x *UTSNamespace) StateFields() []string {
	return []string{
		"hostName",
		"domainName",
		"userns",
	}
}

func (x *UTSNamespace) beforeSave() {}

func (x *UTSNamespace) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.hostName)
	m.Save(1, &x.domainName)
	m.Save(2, &x.userns)
}

func (x *UTSNamespace) afterLoad() {}

func (x *UTSNamespace) StateLoad(m state.Source) {
	m.Load(0, &x.hostName)
	m.Load(1, &x.domainName)
	m.Load(2, &x.userns)
}

func (x *VDSOParamPage) StateTypeName() string {
	return "pkg/sentry/kernel.VDSOParamPage"
}

func (x *VDSOParamPage) StateFields() []string {
	return []string{
		"mfp",
		"fr",
		"seq",
	}
}

func (x *VDSOParamPage) beforeSave() {}

func (x *VDSOParamPage) StateSave(m state.Sink) {
	x.beforeSave()
	m.Save(0, &x.mfp)
	m.Save(1, &x.fr)
	m.Save(2, &x.seq)
}

func (x *VDSOParamPage) afterLoad() {}

func (x *VDSOParamPage) StateLoad(m state.Source) {
	m.Load(0, &x.mfp)
	m.Load(1, &x.fr)
	m.Load(2, &x.seq)
}

func init() {
	state.Register((*abstractEndpoint)(nil))
	state.Register((*AbstractSocketNamespace)(nil))
	state.Register((*FDFlags)(nil))
	state.Register((*descriptor)(nil))
	state.Register((*FDTable)(nil))
	state.Register((*FSContext)(nil))
	state.Register((*IPCNamespace)(nil))
	state.Register((*Kernel)(nil))
	state.Register((*SocketEntry)(nil))
	state.Register((*pendingSignals)(nil))
	state.Register((*pendingSignalQueue)(nil))
	state.Register((*pendingSignal)(nil))
	state.Register((*pendingSignalList)(nil))
	state.Register((*pendingSignalEntry)(nil))
	state.Register((*savedPendingSignal)(nil))
	state.Register((*IntervalTimer)(nil))
	state.Register((*processGroupList)(nil))
	state.Register((*processGroupEntry)(nil))
	state.Register((*ptraceOptions)(nil))
	state.Register((*ptraceStop)(nil))
	state.Register((*OldRSeqCriticalRegion)(nil))
	state.Register((*sessionList)(nil))
	state.Register((*sessionEntry)(nil))
	state.Register((*Session)(nil))
	state.Register((*ProcessGroup)(nil))
	state.Register((*SignalHandlers)(nil))
	state.Register((*socketList)(nil))
	state.Register((*socketEntry)(nil))
	state.Register((*syscallTableInfo)(nil))
	state.Register((*syslog)(nil))
	state.Register((*Task)(nil))
	state.Register((*runSyscallAfterPtraceEventClone)(nil))
	state.Register((*runSyscallAfterVforkStop)(nil))
	state.Register((*vforkStop)(nil))
	state.Register((*TaskContext)(nil))
	state.Register((*execStop)(nil))
	state.Register((*runSyscallAfterExecStop)(nil))
	state.Register((*ExitStatus)(nil))
	state.Register((*runExit)(nil))
	state.Register((*runExitMain)(nil))
	state.Register((*runExitNotify)(nil))
	state.Register((*taskList)(nil))
	state.Register((*taskEntry)(nil))
	state.Register((*runApp)(nil))
	state.Register((*TaskGoroutineSchedInfo)(nil))
	state.Register((*taskClock)(nil))
	state.Register((*tgClock)(nil))
	state.Register((*groupStop)(nil))
	state.Register((*runInterrupt)(nil))
	state.Register((*runInterruptAfterSignalDeliveryStop)(nil))
	state.Register((*runSyscallAfterSyscallEnterStop)(nil))
	state.Register((*runSyscallAfterSysemuStop)(nil))
	state.Register((*runSyscallReinvoke)(nil))
	state.Register((*runSyscallExit)(nil))
	state.Register((*ThreadGroup)(nil))
	state.Register((*itimerRealListener)(nil))
	state.Register((*TaskSet)(nil))
	state.Register((*PIDNamespace)(nil))
	state.Register((*threadGroupNode)(nil))
	state.Register((*taskNode)(nil))
	state.Register((*Timekeeper)(nil))
	state.Register((*timekeeperClock)(nil))
	state.Register((*TTY)(nil))
	state.Register((*UTSNamespace)(nil))
	state.Register((*VDSOParamPage)(nil))
}