// automatically generated by stateify.

package kernel

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

func (x *abstractEndpoint) beforeSave() {}
func (x *abstractEndpoint) save(m state.Map) {
	x.beforeSave()
	m.Save("ep", &x.ep)
	m.Save("wr", &x.wr)
	m.Save("name", &x.name)
	m.Save("ns", &x.ns)
}

func (x *abstractEndpoint) afterLoad() {}
func (x *abstractEndpoint) load(m state.Map) {
	m.Load("ep", &x.ep)
	m.Load("wr", &x.wr)
	m.Load("name", &x.name)
	m.Load("ns", &x.ns)
}

func (x *AbstractSocketNamespace) beforeSave() {}
func (x *AbstractSocketNamespace) save(m state.Map) {
	x.beforeSave()
	m.Save("endpoints", &x.endpoints)
}

func (x *AbstractSocketNamespace) afterLoad() {}
func (x *AbstractSocketNamespace) load(m state.Map) {
	m.Load("endpoints", &x.endpoints)
}

func (x *FDFlags) beforeSave() {}
func (x *FDFlags) save(m state.Map) {
	x.beforeSave()
	m.Save("CloseOnExec", &x.CloseOnExec)
}

func (x *FDFlags) afterLoad() {}
func (x *FDFlags) load(m state.Map) {
	m.Load("CloseOnExec", &x.CloseOnExec)
}

func (x *descriptor) beforeSave() {}
func (x *descriptor) save(m state.Map) {
	x.beforeSave()
	m.Save("file", &x.file)
	m.Save("flags", &x.flags)
}

func (x *descriptor) afterLoad() {}
func (x *descriptor) load(m state.Map) {
	m.Load("file", &x.file)
	m.Load("flags", &x.flags)
}

func (x *FDTable) beforeSave() {}
func (x *FDTable) save(m state.Map) {
	x.beforeSave()
	var descriptorTable map[int32]descriptor = x.saveDescriptorTable()
	m.SaveValue("descriptorTable", descriptorTable)
	m.Save("AtomicRefCount", &x.AtomicRefCount)
	m.Save("k", &x.k)
	m.Save("uid", &x.uid)
	m.Save("used", &x.used)
}

func (x *FDTable) afterLoad() {}
func (x *FDTable) load(m state.Map) {
	m.Load("AtomicRefCount", &x.AtomicRefCount)
	m.Load("k", &x.k)
	m.Load("uid", &x.uid)
	m.Load("used", &x.used)
	m.LoadValue("descriptorTable", new(map[int32]descriptor), func(y interface{}) { x.loadDescriptorTable(y.(map[int32]descriptor)) })
}

func (x *FSContext) beforeSave() {}
func (x *FSContext) save(m state.Map) {
	x.beforeSave()
	m.Save("AtomicRefCount", &x.AtomicRefCount)
	m.Save("root", &x.root)
	m.Save("cwd", &x.cwd)
	m.Save("umask", &x.umask)
}

func (x *FSContext) afterLoad() {}
func (x *FSContext) load(m state.Map) {
	m.Load("AtomicRefCount", &x.AtomicRefCount)
	m.Load("root", &x.root)
	m.Load("cwd", &x.cwd)
	m.Load("umask", &x.umask)
}

func (x *IPCNamespace) beforeSave() {}
func (x *IPCNamespace) save(m state.Map) {
	x.beforeSave()
	m.Save("userNS", &x.userNS)
	m.Save("semaphores", &x.semaphores)
	m.Save("shms", &x.shms)
}

func (x *IPCNamespace) afterLoad() {}
func (x *IPCNamespace) load(m state.Map) {
	m.Load("userNS", &x.userNS)
	m.Load("semaphores", &x.semaphores)
	m.Load("shms", &x.shms)
}

func (x *Kernel) beforeSave() {}
func (x *Kernel) save(m state.Map) {
	x.beforeSave()
	var danglingEndpoints []tcpip.Endpoint = x.saveDanglingEndpoints()
	m.SaveValue("danglingEndpoints", danglingEndpoints)
	var deviceRegistry *device.Registry = x.saveDeviceRegistry()
	m.SaveValue("deviceRegistry", deviceRegistry)
	m.Save("featureSet", &x.featureSet)
	m.Save("timekeeper", &x.timekeeper)
	m.Save("tasks", &x.tasks)
	m.Save("rootUserNamespace", &x.rootUserNamespace)
	m.Save("applicationCores", &x.applicationCores)
	m.Save("useHostCores", &x.useHostCores)
	m.Save("extraAuxv", &x.extraAuxv)
	m.Save("vdso", &x.vdso)
	m.Save("rootUTSNamespace", &x.rootUTSNamespace)
	m.Save("rootIPCNamespace", &x.rootIPCNamespace)
	m.Save("rootAbstractSocketNamespace", &x.rootAbstractSocketNamespace)
	m.Save("futexes", &x.futexes)
	m.Save("globalInit", &x.globalInit)
	m.Save("realtimeClock", &x.realtimeClock)
	m.Save("monotonicClock", &x.monotonicClock)
	m.Save("syslog", &x.syslog)
	m.Save("cpuClock", &x.cpuClock)
	m.Save("fdMapUids", &x.fdMapUids)
	m.Save("uniqueID", &x.uniqueID)
	m.Save("nextInotifyCookie", &x.nextInotifyCookie)
	m.Save("netlinkPorts", &x.netlinkPorts)
	m.Save("sockets", &x.sockets)
	m.Save("nextSocketEntry", &x.nextSocketEntry)
	m.Save("DirentCacheLimiter", &x.DirentCacheLimiter)
}

func (x *Kernel) afterLoad() {}
func (x *Kernel) load(m state.Map) {
	m.Load("featureSet", &x.featureSet)
	m.Load("timekeeper", &x.timekeeper)
	m.Load("tasks", &x.tasks)
	m.Load("rootUserNamespace", &x.rootUserNamespace)
	m.Load("applicationCores", &x.applicationCores)
	m.Load("useHostCores", &x.useHostCores)
	m.Load("extraAuxv", &x.extraAuxv)
	m.Load("vdso", &x.vdso)
	m.Load("rootUTSNamespace", &x.rootUTSNamespace)
	m.Load("rootIPCNamespace", &x.rootIPCNamespace)
	m.Load("rootAbstractSocketNamespace", &x.rootAbstractSocketNamespace)
	m.Load("futexes", &x.futexes)
	m.Load("globalInit", &x.globalInit)
	m.Load("realtimeClock", &x.realtimeClock)
	m.Load("monotonicClock", &x.monotonicClock)
	m.Load("syslog", &x.syslog)
	m.Load("cpuClock", &x.cpuClock)
	m.Load("fdMapUids", &x.fdMapUids)
	m.Load("uniqueID", &x.uniqueID)
	m.Load("nextInotifyCookie", &x.nextInotifyCookie)
	m.Load("netlinkPorts", &x.netlinkPorts)
	m.Load("sockets", &x.sockets)
	m.Load("nextSocketEntry", &x.nextSocketEntry)
	m.Load("DirentCacheLimiter", &x.DirentCacheLimiter)
	m.LoadValue("danglingEndpoints", new([]tcpip.Endpoint), func(y interface{}) { x.loadDanglingEndpoints(y.([]tcpip.Endpoint)) })
	m.LoadValue("deviceRegistry", new(*device.Registry), func(y interface{}) { x.loadDeviceRegistry(y.(*device.Registry)) })
}

func (x *SocketEntry) beforeSave() {}
func (x *SocketEntry) save(m state.Map) {
	x.beforeSave()
	m.Save("socketEntry", &x.socketEntry)
	m.Save("k", &x.k)
	m.Save("Sock", &x.Sock)
	m.Save("ID", &x.ID)
}

func (x *SocketEntry) afterLoad() {}
func (x *SocketEntry) load(m state.Map) {
	m.Load("socketEntry", &x.socketEntry)
	m.Load("k", &x.k)
	m.Load("Sock", &x.Sock)
	m.Load("ID", &x.ID)
}

func (x *pendingSignals) beforeSave() {}
func (x *pendingSignals) save(m state.Map) {
	x.beforeSave()
	var signals []savedPendingSignal = x.saveSignals()
	m.SaveValue("signals", signals)
}

func (x *pendingSignals) afterLoad() {}
func (x *pendingSignals) load(m state.Map) {
	m.LoadValue("signals", new([]savedPendingSignal), func(y interface{}) { x.loadSignals(y.([]savedPendingSignal)) })
}

func (x *pendingSignalQueue) beforeSave() {}
func (x *pendingSignalQueue) save(m state.Map) {
	x.beforeSave()
	m.Save("pendingSignalList", &x.pendingSignalList)
	m.Save("length", &x.length)
}

func (x *pendingSignalQueue) afterLoad() {}
func (x *pendingSignalQueue) load(m state.Map) {
	m.Load("pendingSignalList", &x.pendingSignalList)
	m.Load("length", &x.length)
}

func (x *pendingSignal) beforeSave() {}
func (x *pendingSignal) save(m state.Map) {
	x.beforeSave()
	m.Save("pendingSignalEntry", &x.pendingSignalEntry)
	m.Save("SignalInfo", &x.SignalInfo)
	m.Save("timer", &x.timer)
}

func (x *pendingSignal) afterLoad() {}
func (x *pendingSignal) load(m state.Map) {
	m.Load("pendingSignalEntry", &x.pendingSignalEntry)
	m.Load("SignalInfo", &x.SignalInfo)
	m.Load("timer", &x.timer)
}

func (x *pendingSignalList) beforeSave() {}
func (x *pendingSignalList) save(m state.Map) {
	x.beforeSave()
	m.Save("head", &x.head)
	m.Save("tail", &x.tail)
}

func (x *pendingSignalList) afterLoad() {}
func (x *pendingSignalList) load(m state.Map) {
	m.Load("head", &x.head)
	m.Load("tail", &x.tail)
}

func (x *pendingSignalEntry) beforeSave() {}
func (x *pendingSignalEntry) save(m state.Map) {
	x.beforeSave()
	m.Save("next", &x.next)
	m.Save("prev", &x.prev)
}

func (x *pendingSignalEntry) afterLoad() {}
func (x *pendingSignalEntry) load(m state.Map) {
	m.Load("next", &x.next)
	m.Load("prev", &x.prev)
}

func (x *savedPendingSignal) beforeSave() {}
func (x *savedPendingSignal) save(m state.Map) {
	x.beforeSave()
	m.Save("si", &x.si)
	m.Save("timer", &x.timer)
}

func (x *savedPendingSignal) afterLoad() {}
func (x *savedPendingSignal) load(m state.Map) {
	m.Load("si", &x.si)
	m.Load("timer", &x.timer)
}

func (x *IntervalTimer) beforeSave() {}
func (x *IntervalTimer) save(m state.Map) {
	x.beforeSave()
	m.Save("timer", &x.timer)
	m.Save("target", &x.target)
	m.Save("signo", &x.signo)
	m.Save("id", &x.id)
	m.Save("sigval", &x.sigval)
	m.Save("group", &x.group)
	m.Save("sigpending", &x.sigpending)
	m.Save("sigorphan", &x.sigorphan)
	m.Save("overrunCur", &x.overrunCur)
	m.Save("overrunLast", &x.overrunLast)
}

func (x *IntervalTimer) afterLoad() {}
func (x *IntervalTimer) load(m state.Map) {
	m.Load("timer", &x.timer)
	m.Load("target", &x.target)
	m.Load("signo", &x.signo)
	m.Load("id", &x.id)
	m.Load("sigval", &x.sigval)
	m.Load("group", &x.group)
	m.Load("sigpending", &x.sigpending)
	m.Load("sigorphan", &x.sigorphan)
	m.Load("overrunCur", &x.overrunCur)
	m.Load("overrunLast", &x.overrunLast)
}

func (x *processGroupList) beforeSave() {}
func (x *processGroupList) save(m state.Map) {
	x.beforeSave()
	m.Save("head", &x.head)
	m.Save("tail", &x.tail)
}

func (x *processGroupList) afterLoad() {}
func (x *processGroupList) load(m state.Map) {
	m.Load("head", &x.head)
	m.Load("tail", &x.tail)
}

func (x *processGroupEntry) beforeSave() {}
func (x *processGroupEntry) save(m state.Map) {
	x.beforeSave()
	m.Save("next", &x.next)
	m.Save("prev", &x.prev)
}

func (x *processGroupEntry) afterLoad() {}
func (x *processGroupEntry) load(m state.Map) {
	m.Load("next", &x.next)
	m.Load("prev", &x.prev)
}

func (x *ptraceOptions) beforeSave() {}
func (x *ptraceOptions) save(m state.Map) {
	x.beforeSave()
	m.Save("ExitKill", &x.ExitKill)
	m.Save("SysGood", &x.SysGood)
	m.Save("TraceClone", &x.TraceClone)
	m.Save("TraceExec", &x.TraceExec)
	m.Save("TraceExit", &x.TraceExit)
	m.Save("TraceFork", &x.TraceFork)
	m.Save("TraceSeccomp", &x.TraceSeccomp)
	m.Save("TraceVfork", &x.TraceVfork)
	m.Save("TraceVforkDone", &x.TraceVforkDone)
}

func (x *ptraceOptions) afterLoad() {}
func (x *ptraceOptions) load(m state.Map) {
	m.Load("ExitKill", &x.ExitKill)
	m.Load("SysGood", &x.SysGood)
	m.Load("TraceClone", &x.TraceClone)
	m.Load("TraceExec", &x.TraceExec)
	m.Load("TraceExit", &x.TraceExit)
	m.Load("TraceFork", &x.TraceFork)
	m.Load("TraceSeccomp", &x.TraceSeccomp)
	m.Load("TraceVfork", &x.TraceVfork)
	m.Load("TraceVforkDone", &x.TraceVforkDone)
}

func (x *ptraceStop) beforeSave() {}
func (x *ptraceStop) save(m state.Map) {
	x.beforeSave()
	m.Save("frozen", &x.frozen)
	m.Save("listen", &x.listen)
}

func (x *ptraceStop) afterLoad() {}
func (x *ptraceStop) load(m state.Map) {
	m.Load("frozen", &x.frozen)
	m.Load("listen", &x.listen)
}

func (x *RSEQCriticalRegion) beforeSave() {}
func (x *RSEQCriticalRegion) save(m state.Map) {
	x.beforeSave()
	m.Save("CriticalSection", &x.CriticalSection)
	m.Save("Restart", &x.Restart)
}

func (x *RSEQCriticalRegion) afterLoad() {}
func (x *RSEQCriticalRegion) load(m state.Map) {
	m.Load("CriticalSection", &x.CriticalSection)
	m.Load("Restart", &x.Restart)
}

func (x *sessionList) beforeSave() {}
func (x *sessionList) save(m state.Map) {
	x.beforeSave()
	m.Save("head", &x.head)
	m.Save("tail", &x.tail)
}

func (x *sessionList) afterLoad() {}
func (x *sessionList) load(m state.Map) {
	m.Load("head", &x.head)
	m.Load("tail", &x.tail)
}

func (x *sessionEntry) beforeSave() {}
func (x *sessionEntry) save(m state.Map) {
	x.beforeSave()
	m.Save("next", &x.next)
	m.Save("prev", &x.prev)
}

func (x *sessionEntry) afterLoad() {}
func (x *sessionEntry) load(m state.Map) {
	m.Load("next", &x.next)
	m.Load("prev", &x.prev)
}

func (x *Session) beforeSave() {}
func (x *Session) save(m state.Map) {
	x.beforeSave()
	m.Save("refs", &x.refs)
	m.Save("leader", &x.leader)
	m.Save("id", &x.id)
	m.Save("foreground", &x.foreground)
	m.Save("processGroups", &x.processGroups)
	m.Save("sessionEntry", &x.sessionEntry)
}

func (x *Session) afterLoad() {}
func (x *Session) load(m state.Map) {
	m.Load("refs", &x.refs)
	m.Load("leader", &x.leader)
	m.Load("id", &x.id)
	m.Load("foreground", &x.foreground)
	m.Load("processGroups", &x.processGroups)
	m.Load("sessionEntry", &x.sessionEntry)
}

func (x *ProcessGroup) beforeSave() {}
func (x *ProcessGroup) save(m state.Map) {
	x.beforeSave()
	m.Save("refs", &x.refs)
	m.Save("originator", &x.originator)
	m.Save("id", &x.id)
	m.Save("session", &x.session)
	m.Save("ancestors", &x.ancestors)
	m.Save("processGroupEntry", &x.processGroupEntry)
}

func (x *ProcessGroup) afterLoad() {}
func (x *ProcessGroup) load(m state.Map) {
	m.Load("refs", &x.refs)
	m.Load("originator", &x.originator)
	m.Load("id", &x.id)
	m.Load("session", &x.session)
	m.Load("ancestors", &x.ancestors)
	m.Load("processGroupEntry", &x.processGroupEntry)
}

func (x *SignalHandlers) beforeSave() {}
func (x *SignalHandlers) save(m state.Map) {
	x.beforeSave()
	m.Save("actions", &x.actions)
}

func (x *SignalHandlers) afterLoad() {}
func (x *SignalHandlers) load(m state.Map) {
	m.Load("actions", &x.actions)
}

func (x *socketList) beforeSave() {}
func (x *socketList) save(m state.Map) {
	x.beforeSave()
	m.Save("head", &x.head)
	m.Save("tail", &x.tail)
}

func (x *socketList) afterLoad() {}
func (x *socketList) load(m state.Map) {
	m.Load("head", &x.head)
	m.Load("tail", &x.tail)
}

func (x *socketEntry) beforeSave() {}
func (x *socketEntry) save(m state.Map) {
	x.beforeSave()
	m.Save("next", &x.next)
	m.Save("prev", &x.prev)
}

func (x *socketEntry) afterLoad() {}
func (x *socketEntry) load(m state.Map) {
	m.Load("next", &x.next)
	m.Load("prev", &x.prev)
}

func (x *SyscallTable) beforeSave() {}
func (x *SyscallTable) save(m state.Map) {
	x.beforeSave()
	m.Save("OS", &x.OS)
	m.Save("Arch", &x.Arch)
}

func (x *SyscallTable) load(m state.Map) {
	m.LoadWait("OS", &x.OS)
	m.LoadWait("Arch", &x.Arch)
	m.AfterLoad(x.afterLoad)
}

func (x *syslog) beforeSave() {}
func (x *syslog) save(m state.Map) {
	x.beforeSave()
	m.Save("msg", &x.msg)
}

func (x *syslog) afterLoad() {}
func (x *syslog) load(m state.Map) {
	m.Load("msg", &x.msg)
}

func (x *Task) beforeSave() {}
func (x *Task) save(m state.Map) {
	x.beforeSave()
	if !state.IsZeroValue(x.signalQueue) { m.Failf("signalQueue is %v, expected zero", x.signalQueue) }
	var ptraceTracer *Task = x.savePtraceTracer()
	m.SaveValue("ptraceTracer", ptraceTracer)
	var logPrefix string = x.saveLogPrefix()
	m.SaveValue("logPrefix", logPrefix)
	var syscallFilters []bpf.Program = x.saveSyscallFilters()
	m.SaveValue("syscallFilters", syscallFilters)
	m.Save("taskNode", &x.taskNode)
	m.Save("runState", &x.runState)
	m.Save("haveSyscallReturn", &x.haveSyscallReturn)
	m.Save("gosched", &x.gosched)
	m.Save("yieldCount", &x.yieldCount)
	m.Save("pendingSignals", &x.pendingSignals)
	m.Save("signalMask", &x.signalMask)
	m.Save("realSignalMask", &x.realSignalMask)
	m.Save("haveSavedSignalMask", &x.haveSavedSignalMask)
	m.Save("savedSignalMask", &x.savedSignalMask)
	m.Save("signalStack", &x.signalStack)
	m.Save("groupStopPending", &x.groupStopPending)
	m.Save("groupStopAcknowledged", &x.groupStopAcknowledged)
	m.Save("trapStopPending", &x.trapStopPending)
	m.Save("trapNotifyPending", &x.trapNotifyPending)
	m.Save("stop", &x.stop)
	m.Save("exitStatus", &x.exitStatus)
	m.Save("syscallRestartBlock", &x.syscallRestartBlock)
	m.Save("k", &x.k)
	m.Save("containerID", &x.containerID)
	m.Save("tc", &x.tc)
	m.Save("fsContext", &x.fsContext)
	m.Save("fdTable", &x.fdTable)
	m.Save("vforkParent", &x.vforkParent)
	m.Save("exitState", &x.exitState)
	m.Save("exitTracerNotified", &x.exitTracerNotified)
	m.Save("exitTracerAcked", &x.exitTracerAcked)
	m.Save("exitParentNotified", &x.exitParentNotified)
	m.Save("exitParentAcked", &x.exitParentAcked)
	m.Save("ptraceTracees", &x.ptraceTracees)
	m.Save("ptraceSeized", &x.ptraceSeized)
	m.Save("ptraceOpts", &x.ptraceOpts)
	m.Save("ptraceSyscallMode", &x.ptraceSyscallMode)
	m.Save("ptraceSinglestep", &x.ptraceSinglestep)
	m.Save("ptraceCode", &x.ptraceCode)
	m.Save("ptraceSiginfo", &x.ptraceSiginfo)
	m.Save("ptraceEventMsg", &x.ptraceEventMsg)
	m.Save("ioUsage", &x.ioUsage)
	m.Save("creds", &x.creds)
	m.Save("utsns", &x.utsns)
	m.Save("ipcns", &x.ipcns)
	m.Save("abstractSockets", &x.abstractSockets)
	m.Save("parentDeathSignal", &x.parentDeathSignal)
	m.Save("cleartid", &x.cleartid)
	m.Save("allowedCPUMask", &x.allowedCPUMask)
	m.Save("cpu", &x.cpu)
	m.Save("niceness", &x.niceness)
	m.Save("numaPolicy", &x.numaPolicy)
	m.Save("numaNodeMask", &x.numaNodeMask)
	m.Save("netns", &x.netns)
	m.Save("rseqCPUAddr", &x.rseqCPUAddr)
	m.Save("rseqCPU", &x.rseqCPU)
	m.Save("startTime", &x.startTime)
}

func (x *Task) load(m state.Map) {
	m.Load("taskNode", &x.taskNode)
	m.Load("runState", &x.runState)
	m.Load("haveSyscallReturn", &x.haveSyscallReturn)
	m.Load("gosched", &x.gosched)
	m.Load("yieldCount", &x.yieldCount)
	m.Load("pendingSignals", &x.pendingSignals)
	m.Load("signalMask", &x.signalMask)
	m.Load("realSignalMask", &x.realSignalMask)
	m.Load("haveSavedSignalMask", &x.haveSavedSignalMask)
	m.Load("savedSignalMask", &x.savedSignalMask)
	m.Load("signalStack", &x.signalStack)
	m.Load("groupStopPending", &x.groupStopPending)
	m.Load("groupStopAcknowledged", &x.groupStopAcknowledged)
	m.Load("trapStopPending", &x.trapStopPending)
	m.Load("trapNotifyPending", &x.trapNotifyPending)
	m.Load("stop", &x.stop)
	m.Load("exitStatus", &x.exitStatus)
	m.Load("syscallRestartBlock", &x.syscallRestartBlock)
	m.Load("k", &x.k)
	m.Load("containerID", &x.containerID)
	m.Load("tc", &x.tc)
	m.Load("fsContext", &x.fsContext)
	m.Load("fdTable", &x.fdTable)
	m.Load("vforkParent", &x.vforkParent)
	m.Load("exitState", &x.exitState)
	m.Load("exitTracerNotified", &x.exitTracerNotified)
	m.Load("exitTracerAcked", &x.exitTracerAcked)
	m.Load("exitParentNotified", &x.exitParentNotified)
	m.Load("exitParentAcked", &x.exitParentAcked)
	m.Load("ptraceTracees", &x.ptraceTracees)
	m.Load("ptraceSeized", &x.ptraceSeized)
	m.Load("ptraceOpts", &x.ptraceOpts)
	m.Load("ptraceSyscallMode", &x.ptraceSyscallMode)
	m.Load("ptraceSinglestep", &x.ptraceSinglestep)
	m.Load("ptraceCode", &x.ptraceCode)
	m.Load("ptraceSiginfo", &x.ptraceSiginfo)
	m.Load("ptraceEventMsg", &x.ptraceEventMsg)
	m.Load("ioUsage", &x.ioUsage)
	m.Load("creds", &x.creds)
	m.Load("utsns", &x.utsns)
	m.Load("ipcns", &x.ipcns)
	m.Load("abstractSockets", &x.abstractSockets)
	m.Load("parentDeathSignal", &x.parentDeathSignal)
	m.Load("cleartid", &x.cleartid)
	m.Load("allowedCPUMask", &x.allowedCPUMask)
	m.Load("cpu", &x.cpu)
	m.Load("niceness", &x.niceness)
	m.Load("numaPolicy", &x.numaPolicy)
	m.Load("numaNodeMask", &x.numaNodeMask)
	m.Load("netns", &x.netns)
	m.Load("rseqCPUAddr", &x.rseqCPUAddr)
	m.Load("rseqCPU", &x.rseqCPU)
	m.Load("startTime", &x.startTime)
	m.LoadValue("ptraceTracer", new(*Task), func(y interface{}) { x.loadPtraceTracer(y.(*Task)) })
	m.LoadValue("logPrefix", new(string), func(y interface{}) { x.loadLogPrefix(y.(string)) })
	m.LoadValue("syscallFilters", new([]bpf.Program), func(y interface{}) { x.loadSyscallFilters(y.([]bpf.Program)) })
	m.AfterLoad(x.afterLoad)
}

func (x *runSyscallAfterPtraceEventClone) beforeSave() {}
func (x *runSyscallAfterPtraceEventClone) save(m state.Map) {
	x.beforeSave()
	m.Save("vforkChild", &x.vforkChild)
	m.Save("vforkChildTID", &x.vforkChildTID)
}

func (x *runSyscallAfterPtraceEventClone) afterLoad() {}
func (x *runSyscallAfterPtraceEventClone) load(m state.Map) {
	m.Load("vforkChild", &x.vforkChild)
	m.Load("vforkChildTID", &x.vforkChildTID)
}

func (x *runSyscallAfterVforkStop) beforeSave() {}
func (x *runSyscallAfterVforkStop) save(m state.Map) {
	x.beforeSave()
	m.Save("childTID", &x.childTID)
}

func (x *runSyscallAfterVforkStop) afterLoad() {}
func (x *runSyscallAfterVforkStop) load(m state.Map) {
	m.Load("childTID", &x.childTID)
}

func (x *vforkStop) beforeSave() {}
func (x *vforkStop) save(m state.Map) {
	x.beforeSave()
}

func (x *vforkStop) afterLoad() {}
func (x *vforkStop) load(m state.Map) {
}

func (x *TaskContext) beforeSave() {}
func (x *TaskContext) save(m state.Map) {
	x.beforeSave()
	m.Save("Name", &x.Name)
	m.Save("Arch", &x.Arch)
	m.Save("MemoryManager", &x.MemoryManager)
	m.Save("fu", &x.fu)
	m.Save("st", &x.st)
}

func (x *TaskContext) afterLoad() {}
func (x *TaskContext) load(m state.Map) {
	m.Load("Name", &x.Name)
	m.Load("Arch", &x.Arch)
	m.Load("MemoryManager", &x.MemoryManager)
	m.Load("fu", &x.fu)
	m.Load("st", &x.st)
}

func (x *execStop) beforeSave() {}
func (x *execStop) save(m state.Map) {
	x.beforeSave()
}

func (x *execStop) afterLoad() {}
func (x *execStop) load(m state.Map) {
}

func (x *runSyscallAfterExecStop) beforeSave() {}
func (x *runSyscallAfterExecStop) save(m state.Map) {
	x.beforeSave()
	m.Save("tc", &x.tc)
}

func (x *runSyscallAfterExecStop) afterLoad() {}
func (x *runSyscallAfterExecStop) load(m state.Map) {
	m.Load("tc", &x.tc)
}

func (x *ExitStatus) beforeSave() {}
func (x *ExitStatus) save(m state.Map) {
	x.beforeSave()
	m.Save("Code", &x.Code)
	m.Save("Signo", &x.Signo)
}

func (x *ExitStatus) afterLoad() {}
func (x *ExitStatus) load(m state.Map) {
	m.Load("Code", &x.Code)
	m.Load("Signo", &x.Signo)
}

func (x *runExit) beforeSave() {}
func (x *runExit) save(m state.Map) {
	x.beforeSave()
}

func (x *runExit) afterLoad() {}
func (x *runExit) load(m state.Map) {
}

func (x *runExitMain) beforeSave() {}
func (x *runExitMain) save(m state.Map) {
	x.beforeSave()
}

func (x *runExitMain) afterLoad() {}
func (x *runExitMain) load(m state.Map) {
}

func (x *runExitNotify) beforeSave() {}
func (x *runExitNotify) save(m state.Map) {
	x.beforeSave()
}

func (x *runExitNotify) afterLoad() {}
func (x *runExitNotify) load(m state.Map) {
}

func (x *taskList) beforeSave() {}
func (x *taskList) save(m state.Map) {
	x.beforeSave()
	m.Save("head", &x.head)
	m.Save("tail", &x.tail)
}

func (x *taskList) afterLoad() {}
func (x *taskList) load(m state.Map) {
	m.Load("head", &x.head)
	m.Load("tail", &x.tail)
}

func (x *taskEntry) beforeSave() {}
func (x *taskEntry) save(m state.Map) {
	x.beforeSave()
	m.Save("next", &x.next)
	m.Save("prev", &x.prev)
}

func (x *taskEntry) afterLoad() {}
func (x *taskEntry) load(m state.Map) {
	m.Load("next", &x.next)
	m.Load("prev", &x.prev)
}

func (x *runApp) beforeSave() {}
func (x *runApp) save(m state.Map) {
	x.beforeSave()
}

func (x *runApp) afterLoad() {}
func (x *runApp) load(m state.Map) {
}

func (x *TaskGoroutineSchedInfo) beforeSave() {}
func (x *TaskGoroutineSchedInfo) save(m state.Map) {
	x.beforeSave()
	m.Save("Timestamp", &x.Timestamp)
	m.Save("State", &x.State)
	m.Save("UserTicks", &x.UserTicks)
	m.Save("SysTicks", &x.SysTicks)
}

func (x *TaskGoroutineSchedInfo) afterLoad() {}
func (x *TaskGoroutineSchedInfo) load(m state.Map) {
	m.Load("Timestamp", &x.Timestamp)
	m.Load("State", &x.State)
	m.Load("UserTicks", &x.UserTicks)
	m.Load("SysTicks", &x.SysTicks)
}

func (x *taskClock) beforeSave() {}
func (x *taskClock) save(m state.Map) {
	x.beforeSave()
	m.Save("t", &x.t)
	m.Save("includeSys", &x.includeSys)
}

func (x *taskClock) afterLoad() {}
func (x *taskClock) load(m state.Map) {
	m.Load("t", &x.t)
	m.Load("includeSys", &x.includeSys)
}

func (x *tgClock) beforeSave() {}
func (x *tgClock) save(m state.Map) {
	x.beforeSave()
	m.Save("tg", &x.tg)
	m.Save("includeSys", &x.includeSys)
}

func (x *tgClock) afterLoad() {}
func (x *tgClock) load(m state.Map) {
	m.Load("tg", &x.tg)
	m.Load("includeSys", &x.includeSys)
}

func (x *groupStop) beforeSave() {}
func (x *groupStop) save(m state.Map) {
	x.beforeSave()
}

func (x *groupStop) afterLoad() {}
func (x *groupStop) load(m state.Map) {
}

func (x *runInterrupt) beforeSave() {}
func (x *runInterrupt) save(m state.Map) {
	x.beforeSave()
}

func (x *runInterrupt) afterLoad() {}
func (x *runInterrupt) load(m state.Map) {
}

func (x *runInterruptAfterSignalDeliveryStop) beforeSave() {}
func (x *runInterruptAfterSignalDeliveryStop) save(m state.Map) {
	x.beforeSave()
}

func (x *runInterruptAfterSignalDeliveryStop) afterLoad() {}
func (x *runInterruptAfterSignalDeliveryStop) load(m state.Map) {
}

func (x *runSyscallAfterSyscallEnterStop) beforeSave() {}
func (x *runSyscallAfterSyscallEnterStop) save(m state.Map) {
	x.beforeSave()
}

func (x *runSyscallAfterSyscallEnterStop) afterLoad() {}
func (x *runSyscallAfterSyscallEnterStop) load(m state.Map) {
}

func (x *runSyscallAfterSysemuStop) beforeSave() {}
func (x *runSyscallAfterSysemuStop) save(m state.Map) {
	x.beforeSave()
}

func (x *runSyscallAfterSysemuStop) afterLoad() {}
func (x *runSyscallAfterSysemuStop) load(m state.Map) {
}

func (x *runSyscallReinvoke) beforeSave() {}
func (x *runSyscallReinvoke) save(m state.Map) {
	x.beforeSave()
}

func (x *runSyscallReinvoke) afterLoad() {}
func (x *runSyscallReinvoke) load(m state.Map) {
}

func (x *runSyscallExit) beforeSave() {}
func (x *runSyscallExit) save(m state.Map) {
	x.beforeSave()
}

func (x *runSyscallExit) afterLoad() {}
func (x *runSyscallExit) load(m state.Map) {
}

func (x *ThreadGroup) beforeSave() {}
func (x *ThreadGroup) save(m state.Map) {
	x.beforeSave()
	var rscr *RSEQCriticalRegion = x.saveRscr()
	m.SaveValue("rscr", rscr)
	m.Save("threadGroupNode", &x.threadGroupNode)
	m.Save("signalHandlers", &x.signalHandlers)
	m.Save("pendingSignals", &x.pendingSignals)
	m.Save("groupStopDequeued", &x.groupStopDequeued)
	m.Save("groupStopSignal", &x.groupStopSignal)
	m.Save("groupStopPendingCount", &x.groupStopPendingCount)
	m.Save("groupStopComplete", &x.groupStopComplete)
	m.Save("groupStopWaitable", &x.groupStopWaitable)
	m.Save("groupContNotify", &x.groupContNotify)
	m.Save("groupContInterrupted", &x.groupContInterrupted)
	m.Save("groupContWaitable", &x.groupContWaitable)
	m.Save("exiting", &x.exiting)
	m.Save("exitStatus", &x.exitStatus)
	m.Save("terminationSignal", &x.terminationSignal)
	m.Save("itimerRealTimer", &x.itimerRealTimer)
	m.Save("itimerVirtSetting", &x.itimerVirtSetting)
	m.Save("itimerProfSetting", &x.itimerProfSetting)
	m.Save("rlimitCPUSoftSetting", &x.rlimitCPUSoftSetting)
	m.Save("cpuTimersEnabled", &x.cpuTimersEnabled)
	m.Save("timers", &x.timers)
	m.Save("nextTimerID", &x.nextTimerID)
	m.Save("exitedCPUStats", &x.exitedCPUStats)
	m.Save("childCPUStats", &x.childCPUStats)
	m.Save("ioUsage", &x.ioUsage)
	m.Save("maxRSS", &x.maxRSS)
	m.Save("childMaxRSS", &x.childMaxRSS)
	m.Save("limits", &x.limits)
	m.Save("processGroup", &x.processGroup)
	m.Save("execed", &x.execed)
	m.Save("mounts", &x.mounts)
	m.Save("tty", &x.tty)
}

func (x *ThreadGroup) afterLoad() {}
func (x *ThreadGroup) load(m state.Map) {
	m.Load("threadGroupNode", &x.threadGroupNode)
	m.Load("signalHandlers", &x.signalHandlers)
	m.Load("pendingSignals", &x.pendingSignals)
	m.Load("groupStopDequeued", &x.groupStopDequeued)
	m.Load("groupStopSignal", &x.groupStopSignal)
	m.Load("groupStopPendingCount", &x.groupStopPendingCount)
	m.Load("groupStopComplete", &x.groupStopComplete)
	m.Load("groupStopWaitable", &x.groupStopWaitable)
	m.Load("groupContNotify", &x.groupContNotify)
	m.Load("groupContInterrupted", &x.groupContInterrupted)
	m.Load("groupContWaitable", &x.groupContWaitable)
	m.Load("exiting", &x.exiting)
	m.Load("exitStatus", &x.exitStatus)
	m.Load("terminationSignal", &x.terminationSignal)
	m.Load("itimerRealTimer", &x.itimerRealTimer)
	m.Load("itimerVirtSetting", &x.itimerVirtSetting)
	m.Load("itimerProfSetting", &x.itimerProfSetting)
	m.Load("rlimitCPUSoftSetting", &x.rlimitCPUSoftSetting)
	m.Load("cpuTimersEnabled", &x.cpuTimersEnabled)
	m.Load("timers", &x.timers)
	m.Load("nextTimerID", &x.nextTimerID)
	m.Load("exitedCPUStats", &x.exitedCPUStats)
	m.Load("childCPUStats", &x.childCPUStats)
	m.Load("ioUsage", &x.ioUsage)
	m.Load("maxRSS", &x.maxRSS)
	m.Load("childMaxRSS", &x.childMaxRSS)
	m.Load("limits", &x.limits)
	m.Load("processGroup", &x.processGroup)
	m.Load("execed", &x.execed)
	m.Load("mounts", &x.mounts)
	m.Load("tty", &x.tty)
	m.LoadValue("rscr", new(*RSEQCriticalRegion), func(y interface{}) { x.loadRscr(y.(*RSEQCriticalRegion)) })
}

func (x *itimerRealListener) beforeSave() {}
func (x *itimerRealListener) save(m state.Map) {
	x.beforeSave()
	m.Save("tg", &x.tg)
}

func (x *itimerRealListener) afterLoad() {}
func (x *itimerRealListener) load(m state.Map) {
	m.Load("tg", &x.tg)
}

func (x *TaskSet) beforeSave() {}
func (x *TaskSet) save(m state.Map) {
	x.beforeSave()
	m.Save("Root", &x.Root)
	m.Save("sessions", &x.sessions)
}

func (x *TaskSet) afterLoad() {}
func (x *TaskSet) load(m state.Map) {
	m.Load("Root", &x.Root)
	m.Load("sessions", &x.sessions)
}

func (x *PIDNamespace) beforeSave() {}
func (x *PIDNamespace) save(m state.Map) {
	x.beforeSave()
	m.Save("owner", &x.owner)
	m.Save("parent", &x.parent)
	m.Save("userns", &x.userns)
	m.Save("last", &x.last)
	m.Save("tasks", &x.tasks)
	m.Save("tids", &x.tids)
	m.Save("tgids", &x.tgids)
	m.Save("sessions", &x.sessions)
	m.Save("sids", &x.sids)
	m.Save("processGroups", &x.processGroups)
	m.Save("pgids", &x.pgids)
	m.Save("exiting", &x.exiting)
}

func (x *PIDNamespace) afterLoad() {}
func (x *PIDNamespace) load(m state.Map) {
	m.Load("owner", &x.owner)
	m.Load("parent", &x.parent)
	m.Load("userns", &x.userns)
	m.Load("last", &x.last)
	m.Load("tasks", &x.tasks)
	m.Load("tids", &x.tids)
	m.Load("tgids", &x.tgids)
	m.Load("sessions", &x.sessions)
	m.Load("sids", &x.sids)
	m.Load("processGroups", &x.processGroups)
	m.Load("pgids", &x.pgids)
	m.Load("exiting", &x.exiting)
}

func (x *threadGroupNode) beforeSave() {}
func (x *threadGroupNode) save(m state.Map) {
	x.beforeSave()
	m.Save("pidns", &x.pidns)
	m.Save("leader", &x.leader)
	m.Save("execing", &x.execing)
	m.Save("tasks", &x.tasks)
	m.Save("tasksCount", &x.tasksCount)
	m.Save("liveTasks", &x.liveTasks)
	m.Save("activeTasks", &x.activeTasks)
}

func (x *threadGroupNode) afterLoad() {}
func (x *threadGroupNode) load(m state.Map) {
	m.Load("pidns", &x.pidns)
	m.Load("leader", &x.leader)
	m.Load("execing", &x.execing)
	m.Load("tasks", &x.tasks)
	m.Load("tasksCount", &x.tasksCount)
	m.Load("liveTasks", &x.liveTasks)
	m.Load("activeTasks", &x.activeTasks)
}

func (x *taskNode) beforeSave() {}
func (x *taskNode) save(m state.Map) {
	x.beforeSave()
	m.Save("tg", &x.tg)
	m.Save("taskEntry", &x.taskEntry)
	m.Save("parent", &x.parent)
	m.Save("children", &x.children)
	m.Save("childPIDNamespace", &x.childPIDNamespace)
}

func (x *taskNode) afterLoad() {}
func (x *taskNode) load(m state.Map) {
	m.LoadWait("tg", &x.tg)
	m.Load("taskEntry", &x.taskEntry)
	m.Load("parent", &x.parent)
	m.Load("children", &x.children)
	m.Load("childPIDNamespace", &x.childPIDNamespace)
}

func (x *Timekeeper) save(m state.Map) {
	x.beforeSave()
	m.Save("bootTime", &x.bootTime)
	m.Save("saveMonotonic", &x.saveMonotonic)
	m.Save("saveRealtime", &x.saveRealtime)
	m.Save("params", &x.params)
}

func (x *Timekeeper) load(m state.Map) {
	m.Load("bootTime", &x.bootTime)
	m.Load("saveMonotonic", &x.saveMonotonic)
	m.Load("saveRealtime", &x.saveRealtime)
	m.Load("params", &x.params)
	m.AfterLoad(x.afterLoad)
}

func (x *timekeeperClock) beforeSave() {}
func (x *timekeeperClock) save(m state.Map) {
	x.beforeSave()
	m.Save("tk", &x.tk)
	m.Save("c", &x.c)
}

func (x *timekeeperClock) afterLoad() {}
func (x *timekeeperClock) load(m state.Map) {
	m.Load("tk", &x.tk)
	m.Load("c", &x.c)
}

func (x *TTY) beforeSave() {}
func (x *TTY) save(m state.Map) {
	x.beforeSave()
	m.Save("tg", &x.tg)
}

func (x *TTY) afterLoad() {}
func (x *TTY) load(m state.Map) {
	m.Load("tg", &x.tg)
}

func (x *UTSNamespace) beforeSave() {}
func (x *UTSNamespace) save(m state.Map) {
	x.beforeSave()
	m.Save("hostName", &x.hostName)
	m.Save("domainName", &x.domainName)
	m.Save("userns", &x.userns)
}

func (x *UTSNamespace) afterLoad() {}
func (x *UTSNamespace) load(m state.Map) {
	m.Load("hostName", &x.hostName)
	m.Load("domainName", &x.domainName)
	m.Load("userns", &x.userns)
}

func (x *VDSOParamPage) beforeSave() {}
func (x *VDSOParamPage) save(m state.Map) {
	x.beforeSave()
	m.Save("mfp", &x.mfp)
	m.Save("fr", &x.fr)
	m.Save("seq", &x.seq)
}

func (x *VDSOParamPage) afterLoad() {}
func (x *VDSOParamPage) load(m state.Map) {
	m.Load("mfp", &x.mfp)
	m.Load("fr", &x.fr)
	m.Load("seq", &x.seq)
}

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