// automatically generated by stateify.

package tcpip

import (
	"context"

	"github.com/metacubex/gvisor/pkg/state"
)

func (e *ErrAborted) StateTypeName() string {
	return "pkg/tcpip.ErrAborted"
}

func (e *ErrAborted) StateFields() []string {
	return []string{}
}

func (e *ErrAborted) beforeSave() {}

// +checklocksignore
func (e *ErrAborted) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAborted) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAborted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrAddressFamilyNotSupported) StateTypeName() string {
	return "pkg/tcpip.ErrAddressFamilyNotSupported"
}

func (e *ErrAddressFamilyNotSupported) StateFields() []string {
	return []string{}
}

func (e *ErrAddressFamilyNotSupported) beforeSave() {}

// +checklocksignore
func (e *ErrAddressFamilyNotSupported) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAddressFamilyNotSupported) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAddressFamilyNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrAlreadyBound) StateTypeName() string {
	return "pkg/tcpip.ErrAlreadyBound"
}

func (e *ErrAlreadyBound) StateFields() []string {
	return []string{}
}

func (e *ErrAlreadyBound) beforeSave() {}

// +checklocksignore
func (e *ErrAlreadyBound) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAlreadyBound) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAlreadyBound) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrAlreadyConnected) StateTypeName() string {
	return "pkg/tcpip.ErrAlreadyConnected"
}

func (e *ErrAlreadyConnected) StateFields() []string {
	return []string{}
}

func (e *ErrAlreadyConnected) beforeSave() {}

// +checklocksignore
func (e *ErrAlreadyConnected) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAlreadyConnected) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAlreadyConnected) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrAlreadyConnecting) StateTypeName() string {
	return "pkg/tcpip.ErrAlreadyConnecting"
}

func (e *ErrAlreadyConnecting) StateFields() []string {
	return []string{}
}

func (e *ErrAlreadyConnecting) beforeSave() {}

// +checklocksignore
func (e *ErrAlreadyConnecting) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrAlreadyConnecting) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrAlreadyConnecting) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrBadAddress) StateTypeName() string {
	return "pkg/tcpip.ErrBadAddress"
}

func (e *ErrBadAddress) StateFields() []string {
	return []string{}
}

func (e *ErrBadAddress) beforeSave() {}

// +checklocksignore
func (e *ErrBadAddress) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrBadAddress) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrBadAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrBadBuffer) StateTypeName() string {
	return "pkg/tcpip.ErrBadBuffer"
}

func (e *ErrBadBuffer) StateFields() []string {
	return []string{}
}

func (e *ErrBadBuffer) beforeSave() {}

// +checklocksignore
func (e *ErrBadBuffer) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrBadBuffer) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrBadBuffer) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrBadLocalAddress) StateTypeName() string {
	return "pkg/tcpip.ErrBadLocalAddress"
}

func (e *ErrBadLocalAddress) StateFields() []string {
	return []string{}
}

func (e *ErrBadLocalAddress) beforeSave() {}

// +checklocksignore
func (e *ErrBadLocalAddress) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrBadLocalAddress) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrBadLocalAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrBroadcastDisabled) StateTypeName() string {
	return "pkg/tcpip.ErrBroadcastDisabled"
}

func (e *ErrBroadcastDisabled) StateFields() []string {
	return []string{}
}

func (e *ErrBroadcastDisabled) beforeSave() {}

// +checklocksignore
func (e *ErrBroadcastDisabled) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrBroadcastDisabled) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrBroadcastDisabled) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrClosedForReceive) StateTypeName() string {
	return "pkg/tcpip.ErrClosedForReceive"
}

func (e *ErrClosedForReceive) StateFields() []string {
	return []string{}
}

func (e *ErrClosedForReceive) beforeSave() {}

// +checklocksignore
func (e *ErrClosedForReceive) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrClosedForReceive) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrClosedForReceive) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrClosedForSend) StateTypeName() string {
	return "pkg/tcpip.ErrClosedForSend"
}

func (e *ErrClosedForSend) StateFields() []string {
	return []string{}
}

func (e *ErrClosedForSend) beforeSave() {}

// +checklocksignore
func (e *ErrClosedForSend) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrClosedForSend) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrClosedForSend) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrConnectStarted) StateTypeName() string {
	return "pkg/tcpip.ErrConnectStarted"
}

func (e *ErrConnectStarted) StateFields() []string {
	return []string{}
}

func (e *ErrConnectStarted) beforeSave() {}

// +checklocksignore
func (e *ErrConnectStarted) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrConnectStarted) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrConnectStarted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrConnectionAborted) StateTypeName() string {
	return "pkg/tcpip.ErrConnectionAborted"
}

func (e *ErrConnectionAborted) StateFields() []string {
	return []string{}
}

func (e *ErrConnectionAborted) beforeSave() {}

// +checklocksignore
func (e *ErrConnectionAborted) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrConnectionAborted) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrConnectionAborted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrConnectionRefused) StateTypeName() string {
	return "pkg/tcpip.ErrConnectionRefused"
}

func (e *ErrConnectionRefused) StateFields() []string {
	return []string{}
}

func (e *ErrConnectionRefused) beforeSave() {}

// +checklocksignore
func (e *ErrConnectionRefused) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrConnectionRefused) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrConnectionRefused) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrConnectionReset) StateTypeName() string {
	return "pkg/tcpip.ErrConnectionReset"
}

func (e *ErrConnectionReset) StateFields() []string {
	return []string{}
}

func (e *ErrConnectionReset) beforeSave() {}

// +checklocksignore
func (e *ErrConnectionReset) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrConnectionReset) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrConnectionReset) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrDestinationRequired) StateTypeName() string {
	return "pkg/tcpip.ErrDestinationRequired"
}

func (e *ErrDestinationRequired) StateFields() []string {
	return []string{}
}

func (e *ErrDestinationRequired) beforeSave() {}

// +checklocksignore
func (e *ErrDestinationRequired) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrDestinationRequired) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrDestinationRequired) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrDuplicateAddress) StateTypeName() string {
	return "pkg/tcpip.ErrDuplicateAddress"
}

func (e *ErrDuplicateAddress) StateFields() []string {
	return []string{}
}

func (e *ErrDuplicateAddress) beforeSave() {}

// +checklocksignore
func (e *ErrDuplicateAddress) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrDuplicateAddress) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrDuplicateAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrDuplicateNICID) StateTypeName() string {
	return "pkg/tcpip.ErrDuplicateNICID"
}

func (e *ErrDuplicateNICID) StateFields() []string {
	return []string{}
}

func (e *ErrDuplicateNICID) beforeSave() {}

// +checklocksignore
func (e *ErrDuplicateNICID) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrDuplicateNICID) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrDuplicateNICID) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrInvalidNICID) StateTypeName() string {
	return "pkg/tcpip.ErrInvalidNICID"
}

func (e *ErrInvalidNICID) StateFields() []string {
	return []string{}
}

func (e *ErrInvalidNICID) beforeSave() {}

// +checklocksignore
func (e *ErrInvalidNICID) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrInvalidNICID) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrInvalidNICID) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrInvalidEndpointState) StateTypeName() string {
	return "pkg/tcpip.ErrInvalidEndpointState"
}

func (e *ErrInvalidEndpointState) StateFields() []string {
	return []string{}
}

func (e *ErrInvalidEndpointState) beforeSave() {}

// +checklocksignore
func (e *ErrInvalidEndpointState) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrInvalidEndpointState) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrInvalidEndpointState) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrInvalidOptionValue) StateTypeName() string {
	return "pkg/tcpip.ErrInvalidOptionValue"
}

func (e *ErrInvalidOptionValue) StateFields() []string {
	return []string{}
}

func (e *ErrInvalidOptionValue) beforeSave() {}

// +checklocksignore
func (e *ErrInvalidOptionValue) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrInvalidOptionValue) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrInvalidOptionValue) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrInvalidPortRange) StateTypeName() string {
	return "pkg/tcpip.ErrInvalidPortRange"
}

func (e *ErrInvalidPortRange) StateFields() []string {
	return []string{}
}

func (e *ErrInvalidPortRange) beforeSave() {}

// +checklocksignore
func (e *ErrInvalidPortRange) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrInvalidPortRange) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrInvalidPortRange) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrMalformedHeader) StateTypeName() string {
	return "pkg/tcpip.ErrMalformedHeader"
}

func (e *ErrMalformedHeader) StateFields() []string {
	return []string{}
}

func (e *ErrMalformedHeader) beforeSave() {}

// +checklocksignore
func (e *ErrMalformedHeader) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrMalformedHeader) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrMalformedHeader) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrMessageTooLong) StateTypeName() string {
	return "pkg/tcpip.ErrMessageTooLong"
}

func (e *ErrMessageTooLong) StateFields() []string {
	return []string{}
}

func (e *ErrMessageTooLong) beforeSave() {}

// +checklocksignore
func (e *ErrMessageTooLong) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrMessageTooLong) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrMessageTooLong) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNetworkUnreachable) StateTypeName() string {
	return "pkg/tcpip.ErrNetworkUnreachable"
}

func (e *ErrNetworkUnreachable) StateFields() []string {
	return []string{}
}

func (e *ErrNetworkUnreachable) beforeSave() {}

// +checklocksignore
func (e *ErrNetworkUnreachable) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNetworkUnreachable) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNetworkUnreachable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNoBufferSpace) StateTypeName() string {
	return "pkg/tcpip.ErrNoBufferSpace"
}

func (e *ErrNoBufferSpace) StateFields() []string {
	return []string{}
}

func (e *ErrNoBufferSpace) beforeSave() {}

// +checklocksignore
func (e *ErrNoBufferSpace) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNoBufferSpace) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNoBufferSpace) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNoPortAvailable) StateTypeName() string {
	return "pkg/tcpip.ErrNoPortAvailable"
}

func (e *ErrNoPortAvailable) StateFields() []string {
	return []string{}
}

func (e *ErrNoPortAvailable) beforeSave() {}

// +checklocksignore
func (e *ErrNoPortAvailable) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNoPortAvailable) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNoPortAvailable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrHostUnreachable) StateTypeName() string {
	return "pkg/tcpip.ErrHostUnreachable"
}

func (e *ErrHostUnreachable) StateFields() []string {
	return []string{}
}

func (e *ErrHostUnreachable) beforeSave() {}

// +checklocksignore
func (e *ErrHostUnreachable) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrHostUnreachable) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrHostUnreachable) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrHostDown) StateTypeName() string {
	return "pkg/tcpip.ErrHostDown"
}

func (e *ErrHostDown) StateFields() []string {
	return []string{}
}

func (e *ErrHostDown) beforeSave() {}

// +checklocksignore
func (e *ErrHostDown) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrHostDown) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrHostDown) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNoNet) StateTypeName() string {
	return "pkg/tcpip.ErrNoNet"
}

func (e *ErrNoNet) StateFields() []string {
	return []string{}
}

func (e *ErrNoNet) beforeSave() {}

// +checklocksignore
func (e *ErrNoNet) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNoNet) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNoNet) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNoSuchFile) StateTypeName() string {
	return "pkg/tcpip.ErrNoSuchFile"
}

func (e *ErrNoSuchFile) StateFields() []string {
	return []string{}
}

func (e *ErrNoSuchFile) beforeSave() {}

// +checklocksignore
func (e *ErrNoSuchFile) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNoSuchFile) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNoSuchFile) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNotConnected) StateTypeName() string {
	return "pkg/tcpip.ErrNotConnected"
}

func (e *ErrNotConnected) StateFields() []string {
	return []string{}
}

func (e *ErrNotConnected) beforeSave() {}

// +checklocksignore
func (e *ErrNotConnected) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNotConnected) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNotConnected) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNotPermitted) StateTypeName() string {
	return "pkg/tcpip.ErrNotPermitted"
}

func (e *ErrNotPermitted) StateFields() []string {
	return []string{}
}

func (e *ErrNotPermitted) beforeSave() {}

// +checklocksignore
func (e *ErrNotPermitted) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNotPermitted) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNotPermitted) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrNotSupported) StateTypeName() string {
	return "pkg/tcpip.ErrNotSupported"
}

func (e *ErrNotSupported) StateFields() []string {
	return []string{}
}

func (e *ErrNotSupported) beforeSave() {}

// +checklocksignore
func (e *ErrNotSupported) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrNotSupported) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrPortInUse) StateTypeName() string {
	return "pkg/tcpip.ErrPortInUse"
}

func (e *ErrPortInUse) StateFields() []string {
	return []string{}
}

func (e *ErrPortInUse) beforeSave() {}

// +checklocksignore
func (e *ErrPortInUse) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrPortInUse) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrPortInUse) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrQueueSizeNotSupported) StateTypeName() string {
	return "pkg/tcpip.ErrQueueSizeNotSupported"
}

func (e *ErrQueueSizeNotSupported) StateFields() []string {
	return []string{}
}

func (e *ErrQueueSizeNotSupported) beforeSave() {}

// +checklocksignore
func (e *ErrQueueSizeNotSupported) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrQueueSizeNotSupported) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrQueueSizeNotSupported) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrTimeout) StateTypeName() string {
	return "pkg/tcpip.ErrTimeout"
}

func (e *ErrTimeout) StateFields() []string {
	return []string{}
}

func (e *ErrTimeout) beforeSave() {}

// +checklocksignore
func (e *ErrTimeout) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrTimeout) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrTimeout) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrUnknownDevice) StateTypeName() string {
	return "pkg/tcpip.ErrUnknownDevice"
}

func (e *ErrUnknownDevice) StateFields() []string {
	return []string{}
}

func (e *ErrUnknownDevice) beforeSave() {}

// +checklocksignore
func (e *ErrUnknownDevice) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrUnknownDevice) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrUnknownDevice) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrUnknownNICID) StateTypeName() string {
	return "pkg/tcpip.ErrUnknownNICID"
}

func (e *ErrUnknownNICID) StateFields() []string {
	return []string{}
}

func (e *ErrUnknownNICID) beforeSave() {}

// +checklocksignore
func (e *ErrUnknownNICID) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrUnknownNICID) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrUnknownNICID) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrUnknownProtocol) StateTypeName() string {
	return "pkg/tcpip.ErrUnknownProtocol"
}

func (e *ErrUnknownProtocol) StateFields() []string {
	return []string{}
}

func (e *ErrUnknownProtocol) beforeSave() {}

// +checklocksignore
func (e *ErrUnknownProtocol) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrUnknownProtocol) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrUnknownProtocol) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrUnknownProtocolOption) StateTypeName() string {
	return "pkg/tcpip.ErrUnknownProtocolOption"
}

func (e *ErrUnknownProtocolOption) StateFields() []string {
	return []string{}
}

func (e *ErrUnknownProtocolOption) beforeSave() {}

// +checklocksignore
func (e *ErrUnknownProtocolOption) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrUnknownProtocolOption) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrUnknownProtocolOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrWouldBlock) StateTypeName() string {
	return "pkg/tcpip.ErrWouldBlock"
}

func (e *ErrWouldBlock) StateFields() []string {
	return []string{}
}

func (e *ErrWouldBlock) beforeSave() {}

// +checklocksignore
func (e *ErrWouldBlock) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrWouldBlock) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrWouldBlock) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrMissingRequiredFields) StateTypeName() string {
	return "pkg/tcpip.ErrMissingRequiredFields"
}

func (e *ErrMissingRequiredFields) StateFields() []string {
	return []string{}
}

func (e *ErrMissingRequiredFields) beforeSave() {}

// +checklocksignore
func (e *ErrMissingRequiredFields) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrMissingRequiredFields) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrMissingRequiredFields) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrMulticastInputCannotBeOutput) StateTypeName() string {
	return "pkg/tcpip.ErrMulticastInputCannotBeOutput"
}

func (e *ErrMulticastInputCannotBeOutput) StateFields() []string {
	return []string{}
}

func (e *ErrMulticastInputCannotBeOutput) beforeSave() {}

// +checklocksignore
func (e *ErrMulticastInputCannotBeOutput) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrMulticastInputCannotBeOutput) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrMulticastInputCannotBeOutput) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (e *ErrEndpointBusy) StateTypeName() string {
	return "pkg/tcpip.ErrEndpointBusy"
}

func (e *ErrEndpointBusy) StateFields() []string {
	return []string{}
}

func (e *ErrEndpointBusy) beforeSave() {}

// +checklocksignore
func (e *ErrEndpointBusy) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
}

func (e *ErrEndpointBusy) afterLoad(context.Context) {}

// +checklocksignore
func (e *ErrEndpointBusy) StateLoad(ctx context.Context, stateSourceObject state.Source) {
}

func (l *RouteList) StateTypeName() string {
	return "pkg/tcpip.RouteList"
}

func (l *RouteList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (l *RouteList) beforeSave() {}

// +checklocksignore
func (l *RouteList) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.head)
	stateSinkObject.Save(1, &l.tail)
}

func (l *RouteList) afterLoad(context.Context) {}

// +checklocksignore
func (l *RouteList) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.head)
	stateSourceObject.Load(1, &l.tail)
}

func (e *RouteEntry) StateTypeName() string {
	return "pkg/tcpip.RouteEntry"
}

func (e *RouteEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (e *RouteEntry) beforeSave() {}

// +checklocksignore
func (e *RouteEntry) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
	stateSinkObject.Save(0, &e.next)
	stateSinkObject.Save(1, &e.prev)
}

func (e *RouteEntry) afterLoad(context.Context) {}

// +checklocksignore
func (e *RouteEntry) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &e.next)
	stateSourceObject.Load(1, &e.prev)
}

func (l *sockErrorList) StateTypeName() string {
	return "pkg/tcpip.sockErrorList"
}

func (l *sockErrorList) StateFields() []string {
	return []string{
		"head",
		"tail",
	}
}

func (l *sockErrorList) beforeSave() {}

// +checklocksignore
func (l *sockErrorList) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.head)
	stateSinkObject.Save(1, &l.tail)
}

func (l *sockErrorList) afterLoad(context.Context) {}

// +checklocksignore
func (l *sockErrorList) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.head)
	stateSourceObject.Load(1, &l.tail)
}

func (e *sockErrorEntry) StateTypeName() string {
	return "pkg/tcpip.sockErrorEntry"
}

func (e *sockErrorEntry) StateFields() []string {
	return []string{
		"next",
		"prev",
	}
}

func (e *sockErrorEntry) beforeSave() {}

// +checklocksignore
func (e *sockErrorEntry) StateSave(stateSinkObject state.Sink) {
	e.beforeSave()
	stateSinkObject.Save(0, &e.next)
	stateSinkObject.Save(1, &e.prev)
}

func (e *sockErrorEntry) afterLoad(context.Context) {}

// +checklocksignore
func (e *sockErrorEntry) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &e.next)
	stateSourceObject.Load(1, &e.prev)
}

func (so *SocketOptions) StateTypeName() string {
	return "pkg/tcpip.SocketOptions"
}

func (so *SocketOptions) StateFields() []string {
	return []string{
		"handler",
		"broadcastEnabled",
		"passCredEnabled",
		"noChecksumEnabled",
		"reuseAddressEnabled",
		"reusePortEnabled",
		"keepAliveEnabled",
		"multicastLoopEnabled",
		"receiveTOSEnabled",
		"receiveTTLEnabled",
		"receiveHopLimitEnabled",
		"receiveTClassEnabled",
		"receivePacketInfoEnabled",
		"receiveIPv6PacketInfoEnabled",
		"hdrIncludedEnabled",
		"v6OnlyEnabled",
		"quickAckEnabled",
		"delayOptionEnabled",
		"corkOptionEnabled",
		"receiveOriginalDstAddress",
		"ipv4RecvErrEnabled",
		"ipv6RecvErrEnabled",
		"errQueue",
		"bindToDevice",
		"sendBufferSize",
		"receiveBufferSize",
		"linger",
		"rcvlowat",
		"experimentOptionValue",
	}
}

func (so *SocketOptions) beforeSave() {}

// +checklocksignore
func (so *SocketOptions) StateSave(stateSinkObject state.Sink) {
	so.beforeSave()
	stateSinkObject.Save(0, &so.handler)
	stateSinkObject.Save(1, &so.broadcastEnabled)
	stateSinkObject.Save(2, &so.passCredEnabled)
	stateSinkObject.Save(3, &so.noChecksumEnabled)
	stateSinkObject.Save(4, &so.reuseAddressEnabled)
	stateSinkObject.Save(5, &so.reusePortEnabled)
	stateSinkObject.Save(6, &so.keepAliveEnabled)
	stateSinkObject.Save(7, &so.multicastLoopEnabled)
	stateSinkObject.Save(8, &so.receiveTOSEnabled)
	stateSinkObject.Save(9, &so.receiveTTLEnabled)
	stateSinkObject.Save(10, &so.receiveHopLimitEnabled)
	stateSinkObject.Save(11, &so.receiveTClassEnabled)
	stateSinkObject.Save(12, &so.receivePacketInfoEnabled)
	stateSinkObject.Save(13, &so.receiveIPv6PacketInfoEnabled)
	stateSinkObject.Save(14, &so.hdrIncludedEnabled)
	stateSinkObject.Save(15, &so.v6OnlyEnabled)
	stateSinkObject.Save(16, &so.quickAckEnabled)
	stateSinkObject.Save(17, &so.delayOptionEnabled)
	stateSinkObject.Save(18, &so.corkOptionEnabled)
	stateSinkObject.Save(19, &so.receiveOriginalDstAddress)
	stateSinkObject.Save(20, &so.ipv4RecvErrEnabled)
	stateSinkObject.Save(21, &so.ipv6RecvErrEnabled)
	stateSinkObject.Save(22, &so.errQueue)
	stateSinkObject.Save(23, &so.bindToDevice)
	stateSinkObject.Save(24, &so.sendBufferSize)
	stateSinkObject.Save(25, &so.receiveBufferSize)
	stateSinkObject.Save(26, &so.linger)
	stateSinkObject.Save(27, &so.rcvlowat)
	stateSinkObject.Save(28, &so.experimentOptionValue)
}

func (so *SocketOptions) afterLoad(context.Context) {}

// +checklocksignore
func (so *SocketOptions) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &so.handler)
	stateSourceObject.Load(1, &so.broadcastEnabled)
	stateSourceObject.Load(2, &so.passCredEnabled)
	stateSourceObject.Load(3, &so.noChecksumEnabled)
	stateSourceObject.Load(4, &so.reuseAddressEnabled)
	stateSourceObject.Load(5, &so.reusePortEnabled)
	stateSourceObject.Load(6, &so.keepAliveEnabled)
	stateSourceObject.Load(7, &so.multicastLoopEnabled)
	stateSourceObject.Load(8, &so.receiveTOSEnabled)
	stateSourceObject.Load(9, &so.receiveTTLEnabled)
	stateSourceObject.Load(10, &so.receiveHopLimitEnabled)
	stateSourceObject.Load(11, &so.receiveTClassEnabled)
	stateSourceObject.Load(12, &so.receivePacketInfoEnabled)
	stateSourceObject.Load(13, &so.receiveIPv6PacketInfoEnabled)
	stateSourceObject.Load(14, &so.hdrIncludedEnabled)
	stateSourceObject.Load(15, &so.v6OnlyEnabled)
	stateSourceObject.Load(16, &so.quickAckEnabled)
	stateSourceObject.Load(17, &so.delayOptionEnabled)
	stateSourceObject.Load(18, &so.corkOptionEnabled)
	stateSourceObject.Load(19, &so.receiveOriginalDstAddress)
	stateSourceObject.Load(20, &so.ipv4RecvErrEnabled)
	stateSourceObject.Load(21, &so.ipv6RecvErrEnabled)
	stateSourceObject.Load(22, &so.errQueue)
	stateSourceObject.Load(23, &so.bindToDevice)
	stateSourceObject.Load(24, &so.sendBufferSize)
	stateSourceObject.Load(25, &so.receiveBufferSize)
	stateSourceObject.Load(26, &so.linger)
	stateSourceObject.Load(27, &so.rcvlowat)
	stateSourceObject.Load(28, &so.experimentOptionValue)
}

func (l *LocalSockError) StateTypeName() string {
	return "pkg/tcpip.LocalSockError"
}

func (l *LocalSockError) StateFields() []string {
	return []string{
		"info",
	}
}

func (l *LocalSockError) beforeSave() {}

// +checklocksignore
func (l *LocalSockError) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.info)
}

func (l *LocalSockError) afterLoad(context.Context) {}

// +checklocksignore
func (l *LocalSockError) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.info)
}

func (s *SockError) StateTypeName() string {
	return "pkg/tcpip.SockError"
}

func (s *SockError) StateFields() []string {
	return []string{
		"sockErrorEntry",
		"Err",
		"Cause",
		"Payload",
		"Dst",
		"Offender",
		"NetProto",
	}
}

func (s *SockError) beforeSave() {}

// +checklocksignore
func (s *SockError) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.sockErrorEntry)
	stateSinkObject.Save(1, &s.Err)
	stateSinkObject.Save(2, &s.Cause)
	stateSinkObject.Save(3, &s.Payload)
	stateSinkObject.Save(4, &s.Dst)
	stateSinkObject.Save(5, &s.Offender)
	stateSinkObject.Save(6, &s.NetProto)
}

func (s *SockError) afterLoad(context.Context) {}

// +checklocksignore
func (s *SockError) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.sockErrorEntry)
	stateSourceObject.Load(1, &s.Err)
	stateSourceObject.Load(2, &s.Cause)
	stateSourceObject.Load(3, &s.Payload)
	stateSourceObject.Load(4, &s.Dst)
	stateSourceObject.Load(5, &s.Offender)
	stateSourceObject.Load(6, &s.NetProto)
}

func (s *stdClock) StateTypeName() string {
	return "pkg/tcpip.stdClock"
}

func (s *stdClock) StateFields() []string {
	return []string{
		"monotonicOffset",
	}
}

// +checklocksignore
func (s *stdClock) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.monotonicOffset)
}

// +checklocksignore
func (s *stdClock) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.monotonicOffset)
	stateSourceObject.AfterLoad(func() { s.afterLoad(ctx) })
}

func (st *stdTimer) StateTypeName() string {
	return "pkg/tcpip.stdTimer"
}

func (st *stdTimer) StateFields() []string {
	return []string{
		"t",
	}
}

func (st *stdTimer) beforeSave() {}

// +checklocksignore
func (st *stdTimer) StateSave(stateSinkObject state.Sink) {
	st.beforeSave()
	stateSinkObject.Save(0, &st.t)
}

func (st *stdTimer) afterLoad(context.Context) {}

// +checklocksignore
func (st *stdTimer) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &st.t)
}

func (mt *MonotonicTime) StateTypeName() string {
	return "pkg/tcpip.MonotonicTime"
}

func (mt *MonotonicTime) StateFields() []string {
	return []string{
		"nanoseconds",
	}
}

func (mt *MonotonicTime) beforeSave() {}

// +checklocksignore
func (mt *MonotonicTime) StateSave(stateSinkObject state.Sink) {
	mt.beforeSave()
	stateSinkObject.Save(0, &mt.nanoseconds)
}

func (mt *MonotonicTime) afterLoad(context.Context) {}

// +checklocksignore
func (mt *MonotonicTime) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &mt.nanoseconds)
}

func (a *Address) StateTypeName() string {
	return "pkg/tcpip.Address"
}

func (a *Address) StateFields() []string {
	return []string{
		"addr",
		"length",
	}
}

func (a *Address) beforeSave() {}

// +checklocksignore
func (a *Address) StateSave(stateSinkObject state.Sink) {
	a.beforeSave()
	stateSinkObject.Save(0, &a.addr)
	stateSinkObject.Save(1, &a.length)
}

func (a *Address) afterLoad(context.Context) {}

// +checklocksignore
func (a *Address) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &a.addr)
	stateSourceObject.Load(1, &a.length)
}

func (m *AddressMask) StateTypeName() string {
	return "pkg/tcpip.AddressMask"
}

func (m *AddressMask) StateFields() []string {
	return []string{
		"mask",
		"length",
	}
}

func (m *AddressMask) beforeSave() {}

// +checklocksignore
func (m *AddressMask) StateSave(stateSinkObject state.Sink) {
	m.beforeSave()
	stateSinkObject.Save(0, &m.mask)
	stateSinkObject.Save(1, &m.length)
}

func (m *AddressMask) afterLoad(context.Context) {}

// +checklocksignore
func (m *AddressMask) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &m.mask)
	stateSourceObject.Load(1, &m.length)
}

func (s *Subnet) StateTypeName() string {
	return "pkg/tcpip.Subnet"
}

func (s *Subnet) StateFields() []string {
	return []string{
		"address",
		"mask",
	}
}

func (s *Subnet) beforeSave() {}

// +checklocksignore
func (s *Subnet) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.address)
	stateSinkObject.Save(1, &s.mask)
}

func (s *Subnet) afterLoad(context.Context) {}

// +checklocksignore
func (s *Subnet) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.address)
	stateSourceObject.Load(1, &s.mask)
}

func (f *FullAddress) StateTypeName() string {
	return "pkg/tcpip.FullAddress"
}

func (f *FullAddress) StateFields() []string {
	return []string{
		"NIC",
		"Addr",
		"Port",
		"LinkAddr",
	}
}

func (f *FullAddress) beforeSave() {}

// +checklocksignore
func (f *FullAddress) StateSave(stateSinkObject state.Sink) {
	f.beforeSave()
	stateSinkObject.Save(0, &f.NIC)
	stateSinkObject.Save(1, &f.Addr)
	stateSinkObject.Save(2, &f.Port)
	stateSinkObject.Save(3, &f.LinkAddr)
}

func (f *FullAddress) afterLoad(context.Context) {}

// +checklocksignore
func (f *FullAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &f.NIC)
	stateSourceObject.Load(1, &f.Addr)
	stateSourceObject.Load(2, &f.Port)
	stateSourceObject.Load(3, &f.LinkAddr)
}

func (s *SendableControlMessages) StateTypeName() string {
	return "pkg/tcpip.SendableControlMessages"
}

func (s *SendableControlMessages) StateFields() []string {
	return []string{
		"HasTTL",
		"TTL",
		"HasHopLimit",
		"HopLimit",
		"HasIPv6PacketInfo",
		"IPv6PacketInfo",
	}
}

func (s *SendableControlMessages) beforeSave() {}

// +checklocksignore
func (s *SendableControlMessages) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.HasTTL)
	stateSinkObject.Save(1, &s.TTL)
	stateSinkObject.Save(2, &s.HasHopLimit)
	stateSinkObject.Save(3, &s.HopLimit)
	stateSinkObject.Save(4, &s.HasIPv6PacketInfo)
	stateSinkObject.Save(5, &s.IPv6PacketInfo)
}

func (s *SendableControlMessages) afterLoad(context.Context) {}

// +checklocksignore
func (s *SendableControlMessages) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.HasTTL)
	stateSourceObject.Load(1, &s.TTL)
	stateSourceObject.Load(2, &s.HasHopLimit)
	stateSourceObject.Load(3, &s.HopLimit)
	stateSourceObject.Load(4, &s.HasIPv6PacketInfo)
	stateSourceObject.Load(5, &s.IPv6PacketInfo)
}

func (c *ReceivableControlMessages) StateTypeName() string {
	return "pkg/tcpip.ReceivableControlMessages"
}

func (c *ReceivableControlMessages) StateFields() []string {
	return []string{
		"Timestamp",
		"HasInq",
		"Inq",
		"HasTOS",
		"TOS",
		"HasTTL",
		"TTL",
		"HasHopLimit",
		"HopLimit",
		"HasTimestamp",
		"HasTClass",
		"TClass",
		"HasIPPacketInfo",
		"PacketInfo",
		"HasIPv6PacketInfo",
		"IPv6PacketInfo",
		"HasOriginalDstAddress",
		"OriginalDstAddress",
		"SockErr",
	}
}

func (c *ReceivableControlMessages) beforeSave() {}

// +checklocksignore
func (c *ReceivableControlMessages) StateSave(stateSinkObject state.Sink) {
	c.beforeSave()
	var TimestampValue int64
	TimestampValue = c.saveTimestamp()
	stateSinkObject.SaveValue(0, TimestampValue)
	stateSinkObject.Save(1, &c.HasInq)
	stateSinkObject.Save(2, &c.Inq)
	stateSinkObject.Save(3, &c.HasTOS)
	stateSinkObject.Save(4, &c.TOS)
	stateSinkObject.Save(5, &c.HasTTL)
	stateSinkObject.Save(6, &c.TTL)
	stateSinkObject.Save(7, &c.HasHopLimit)
	stateSinkObject.Save(8, &c.HopLimit)
	stateSinkObject.Save(9, &c.HasTimestamp)
	stateSinkObject.Save(10, &c.HasTClass)
	stateSinkObject.Save(11, &c.TClass)
	stateSinkObject.Save(12, &c.HasIPPacketInfo)
	stateSinkObject.Save(13, &c.PacketInfo)
	stateSinkObject.Save(14, &c.HasIPv6PacketInfo)
	stateSinkObject.Save(15, &c.IPv6PacketInfo)
	stateSinkObject.Save(16, &c.HasOriginalDstAddress)
	stateSinkObject.Save(17, &c.OriginalDstAddress)
	stateSinkObject.Save(18, &c.SockErr)
}

func (c *ReceivableControlMessages) afterLoad(context.Context) {}

// +checklocksignore
func (c *ReceivableControlMessages) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(1, &c.HasInq)
	stateSourceObject.Load(2, &c.Inq)
	stateSourceObject.Load(3, &c.HasTOS)
	stateSourceObject.Load(4, &c.TOS)
	stateSourceObject.Load(5, &c.HasTTL)
	stateSourceObject.Load(6, &c.TTL)
	stateSourceObject.Load(7, &c.HasHopLimit)
	stateSourceObject.Load(8, &c.HopLimit)
	stateSourceObject.Load(9, &c.HasTimestamp)
	stateSourceObject.Load(10, &c.HasTClass)
	stateSourceObject.Load(11, &c.TClass)
	stateSourceObject.Load(12, &c.HasIPPacketInfo)
	stateSourceObject.Load(13, &c.PacketInfo)
	stateSourceObject.Load(14, &c.HasIPv6PacketInfo)
	stateSourceObject.Load(15, &c.IPv6PacketInfo)
	stateSourceObject.Load(16, &c.HasOriginalDstAddress)
	stateSourceObject.Load(17, &c.OriginalDstAddress)
	stateSourceObject.Load(18, &c.SockErr)
	stateSourceObject.LoadValue(0, new(int64), func(y any) { c.loadTimestamp(ctx, y.(int64)) })
}

func (l *LinkPacketInfo) StateTypeName() string {
	return "pkg/tcpip.LinkPacketInfo"
}

func (l *LinkPacketInfo) StateFields() []string {
	return []string{
		"Protocol",
		"PktType",
	}
}

func (l *LinkPacketInfo) beforeSave() {}

// +checklocksignore
func (l *LinkPacketInfo) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.Protocol)
	stateSinkObject.Save(1, &l.PktType)
}

func (l *LinkPacketInfo) afterLoad(context.Context) {}

// +checklocksignore
func (l *LinkPacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.Protocol)
	stateSourceObject.Load(1, &l.PktType)
}

func (t *TCPSendBufferSizeRangeOption) StateTypeName() string {
	return "pkg/tcpip.TCPSendBufferSizeRangeOption"
}

func (t *TCPSendBufferSizeRangeOption) StateFields() []string {
	return []string{
		"Min",
		"Default",
		"Max",
	}
}

func (t *TCPSendBufferSizeRangeOption) beforeSave() {}

// +checklocksignore
func (t *TCPSendBufferSizeRangeOption) StateSave(stateSinkObject state.Sink) {
	t.beforeSave()
	stateSinkObject.Save(0, &t.Min)
	stateSinkObject.Save(1, &t.Default)
	stateSinkObject.Save(2, &t.Max)
}

func (t *TCPSendBufferSizeRangeOption) afterLoad(context.Context) {}

// +checklocksignore
func (t *TCPSendBufferSizeRangeOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &t.Min)
	stateSourceObject.Load(1, &t.Default)
	stateSourceObject.Load(2, &t.Max)
}

func (t *TCPReceiveBufferSizeRangeOption) StateTypeName() string {
	return "pkg/tcpip.TCPReceiveBufferSizeRangeOption"
}

func (t *TCPReceiveBufferSizeRangeOption) StateFields() []string {
	return []string{
		"Min",
		"Default",
		"Max",
	}
}

func (t *TCPReceiveBufferSizeRangeOption) beforeSave() {}

// +checklocksignore
func (t *TCPReceiveBufferSizeRangeOption) StateSave(stateSinkObject state.Sink) {
	t.beforeSave()
	stateSinkObject.Save(0, &t.Min)
	stateSinkObject.Save(1, &t.Default)
	stateSinkObject.Save(2, &t.Max)
}

func (t *TCPReceiveBufferSizeRangeOption) afterLoad(context.Context) {}

// +checklocksignore
func (t *TCPReceiveBufferSizeRangeOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &t.Min)
	stateSourceObject.Load(1, &t.Default)
	stateSourceObject.Load(2, &t.Max)
}

func (f *ICMPv6Filter) StateTypeName() string {
	return "pkg/tcpip.ICMPv6Filter"
}

func (f *ICMPv6Filter) StateFields() []string {
	return []string{
		"DenyType",
	}
}

func (f *ICMPv6Filter) beforeSave() {}

// +checklocksignore
func (f *ICMPv6Filter) StateSave(stateSinkObject state.Sink) {
	f.beforeSave()
	stateSinkObject.Save(0, &f.DenyType)
}

func (f *ICMPv6Filter) afterLoad(context.Context) {}

// +checklocksignore
func (f *ICMPv6Filter) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &f.DenyType)
}

func (t *TpacketReq) StateTypeName() string {
	return "pkg/tcpip.TpacketReq"
}

func (t *TpacketReq) StateFields() []string {
	return []string{
		"TpBlockSize",
		"TpBlockNr",
		"TpFrameSize",
		"TpFrameNr",
	}
}

func (t *TpacketReq) beforeSave() {}

// +checklocksignore
func (t *TpacketReq) StateSave(stateSinkObject state.Sink) {
	t.beforeSave()
	stateSinkObject.Save(0, &t.TpBlockSize)
	stateSinkObject.Save(1, &t.TpBlockNr)
	stateSinkObject.Save(2, &t.TpFrameSize)
	stateSinkObject.Save(3, &t.TpFrameNr)
}

func (t *TpacketReq) afterLoad(context.Context) {}

// +checklocksignore
func (t *TpacketReq) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &t.TpBlockSize)
	stateSourceObject.Load(1, &t.TpBlockNr)
	stateSourceObject.Load(2, &t.TpFrameSize)
	stateSourceObject.Load(3, &t.TpFrameNr)
}

func (t *TpacketStats) StateTypeName() string {
	return "pkg/tcpip.TpacketStats"
}

func (t *TpacketStats) StateFields() []string {
	return []string{
		"Packets",
		"Dropped",
	}
}

func (t *TpacketStats) beforeSave() {}

// +checklocksignore
func (t *TpacketStats) StateSave(stateSinkObject state.Sink) {
	t.beforeSave()
	stateSinkObject.Save(0, &t.Packets)
	stateSinkObject.Save(1, &t.Dropped)
}

func (t *TpacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (t *TpacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &t.Packets)
	stateSourceObject.Load(1, &t.Dropped)
}

func (l *LingerOption) StateTypeName() string {
	return "pkg/tcpip.LingerOption"
}

func (l *LingerOption) StateFields() []string {
	return []string{
		"Enabled",
		"Timeout",
	}
}

func (l *LingerOption) beforeSave() {}

// +checklocksignore
func (l *LingerOption) StateSave(stateSinkObject state.Sink) {
	l.beforeSave()
	stateSinkObject.Save(0, &l.Enabled)
	stateSinkObject.Save(1, &l.Timeout)
}

func (l *LingerOption) afterLoad(context.Context) {}

// +checklocksignore
func (l *LingerOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &l.Enabled)
	stateSourceObject.Load(1, &l.Timeout)
}

func (i *IPPacketInfo) StateTypeName() string {
	return "pkg/tcpip.IPPacketInfo"
}

func (i *IPPacketInfo) StateFields() []string {
	return []string{
		"NIC",
		"LocalAddr",
		"DestinationAddr",
	}
}

func (i *IPPacketInfo) beforeSave() {}

// +checklocksignore
func (i *IPPacketInfo) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.NIC)
	stateSinkObject.Save(1, &i.LocalAddr)
	stateSinkObject.Save(2, &i.DestinationAddr)
}

func (i *IPPacketInfo) afterLoad(context.Context) {}

// +checklocksignore
func (i *IPPacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.NIC)
	stateSourceObject.Load(1, &i.LocalAddr)
	stateSourceObject.Load(2, &i.DestinationAddr)
}

func (i *IPv6PacketInfo) StateTypeName() string {
	return "pkg/tcpip.IPv6PacketInfo"
}

func (i *IPv6PacketInfo) StateFields() []string {
	return []string{
		"Addr",
		"NIC",
	}
}

func (i *IPv6PacketInfo) beforeSave() {}

// +checklocksignore
func (i *IPv6PacketInfo) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.Addr)
	stateSinkObject.Save(1, &i.NIC)
}

func (i *IPv6PacketInfo) afterLoad(context.Context) {}

// +checklocksignore
func (i *IPv6PacketInfo) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.Addr)
	stateSourceObject.Load(1, &i.NIC)
}

func (s *SendBufferSizeOption) StateTypeName() string {
	return "pkg/tcpip.SendBufferSizeOption"
}

func (s *SendBufferSizeOption) StateFields() []string {
	return []string{
		"Min",
		"Default",
		"Max",
	}
}

func (s *SendBufferSizeOption) beforeSave() {}

// +checklocksignore
func (s *SendBufferSizeOption) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.Min)
	stateSinkObject.Save(1, &s.Default)
	stateSinkObject.Save(2, &s.Max)
}

func (s *SendBufferSizeOption) afterLoad(context.Context) {}

// +checklocksignore
func (s *SendBufferSizeOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.Min)
	stateSourceObject.Load(1, &s.Default)
	stateSourceObject.Load(2, &s.Max)
}

func (r *ReceiveBufferSizeOption) StateTypeName() string {
	return "pkg/tcpip.ReceiveBufferSizeOption"
}

func (r *ReceiveBufferSizeOption) StateFields() []string {
	return []string{
		"Min",
		"Default",
		"Max",
	}
}

func (r *ReceiveBufferSizeOption) beforeSave() {}

// +checklocksignore
func (r *ReceiveBufferSizeOption) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.Min)
	stateSinkObject.Save(1, &r.Default)
	stateSinkObject.Save(2, &r.Max)
}

func (r *ReceiveBufferSizeOption) afterLoad(context.Context) {}

// +checklocksignore
func (r *ReceiveBufferSizeOption) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.Min)
	stateSourceObject.Load(1, &r.Default)
	stateSourceObject.Load(2, &r.Max)
}

func (r *Route) StateTypeName() string {
	return "pkg/tcpip.Route"
}

func (r *Route) StateFields() []string {
	return []string{
		"RouteEntry",
		"Destination",
		"Gateway",
		"NIC",
		"SourceHint",
		"MTU",
	}
}

func (r *Route) beforeSave() {}

// +checklocksignore
func (r *Route) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.RouteEntry)
	stateSinkObject.Save(1, &r.Destination)
	stateSinkObject.Save(2, &r.Gateway)
	stateSinkObject.Save(3, &r.NIC)
	stateSinkObject.Save(4, &r.SourceHint)
	stateSinkObject.Save(5, &r.MTU)
}

func (r *Route) afterLoad(context.Context) {}

// +checklocksignore
func (r *Route) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.RouteEntry)
	stateSourceObject.Load(1, &r.Destination)
	stateSourceObject.Load(2, &r.Gateway)
	stateSourceObject.Load(3, &r.NIC)
	stateSourceObject.Load(4, &r.SourceHint)
	stateSourceObject.Load(5, &r.MTU)
}

func (s *StatCounter) StateTypeName() string {
	return "pkg/tcpip.StatCounter"
}

func (s *StatCounter) StateFields() []string {
	return []string{
		"count",
	}
}

func (s *StatCounter) beforeSave() {}

// +checklocksignore
func (s *StatCounter) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.count)
}

func (s *StatCounter) afterLoad(context.Context) {}

// +checklocksignore
func (s *StatCounter) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.count)
}

func (m *MultiCounterStat) StateTypeName() string {
	return "pkg/tcpip.MultiCounterStat"
}

func (m *MultiCounterStat) StateFields() []string {
	return []string{
		"a",
		"b",
	}
}

func (m *MultiCounterStat) beforeSave() {}

// +checklocksignore
func (m *MultiCounterStat) StateSave(stateSinkObject state.Sink) {
	m.beforeSave()
	stateSinkObject.Save(0, &m.a)
	stateSinkObject.Save(1, &m.b)
}

func (m *MultiCounterStat) afterLoad(context.Context) {}

// +checklocksignore
func (m *MultiCounterStat) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &m.a)
	stateSourceObject.Load(1, &m.b)
}

func (i *ICMPv4PacketStats) StateTypeName() string {
	return "pkg/tcpip.ICMPv4PacketStats"
}

func (i *ICMPv4PacketStats) StateFields() []string {
	return []string{
		"EchoRequest",
		"EchoReply",
		"DstUnreachable",
		"SrcQuench",
		"Redirect",
		"TimeExceeded",
		"ParamProblem",
		"Timestamp",
		"TimestampReply",
		"InfoRequest",
		"InfoReply",
	}
}

func (i *ICMPv4PacketStats) beforeSave() {}

// +checklocksignore
func (i *ICMPv4PacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.EchoRequest)
	stateSinkObject.Save(1, &i.EchoReply)
	stateSinkObject.Save(2, &i.DstUnreachable)
	stateSinkObject.Save(3, &i.SrcQuench)
	stateSinkObject.Save(4, &i.Redirect)
	stateSinkObject.Save(5, &i.TimeExceeded)
	stateSinkObject.Save(6, &i.ParamProblem)
	stateSinkObject.Save(7, &i.Timestamp)
	stateSinkObject.Save(8, &i.TimestampReply)
	stateSinkObject.Save(9, &i.InfoRequest)
	stateSinkObject.Save(10, &i.InfoReply)
}

func (i *ICMPv4PacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPv4PacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.EchoRequest)
	stateSourceObject.Load(1, &i.EchoReply)
	stateSourceObject.Load(2, &i.DstUnreachable)
	stateSourceObject.Load(3, &i.SrcQuench)
	stateSourceObject.Load(4, &i.Redirect)
	stateSourceObject.Load(5, &i.TimeExceeded)
	stateSourceObject.Load(6, &i.ParamProblem)
	stateSourceObject.Load(7, &i.Timestamp)
	stateSourceObject.Load(8, &i.TimestampReply)
	stateSourceObject.Load(9, &i.InfoRequest)
	stateSourceObject.Load(10, &i.InfoReply)
}

func (i *ICMPv4SentPacketStats) StateTypeName() string {
	return "pkg/tcpip.ICMPv4SentPacketStats"
}

func (i *ICMPv4SentPacketStats) StateFields() []string {
	return []string{
		"ICMPv4PacketStats",
		"Dropped",
		"RateLimited",
	}
}

func (i *ICMPv4SentPacketStats) beforeSave() {}

// +checklocksignore
func (i *ICMPv4SentPacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.ICMPv4PacketStats)
	stateSinkObject.Save(1, &i.Dropped)
	stateSinkObject.Save(2, &i.RateLimited)
}

func (i *ICMPv4SentPacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPv4SentPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.ICMPv4PacketStats)
	stateSourceObject.Load(1, &i.Dropped)
	stateSourceObject.Load(2, &i.RateLimited)
}

func (i *ICMPv4ReceivedPacketStats) StateTypeName() string {
	return "pkg/tcpip.ICMPv4ReceivedPacketStats"
}

func (i *ICMPv4ReceivedPacketStats) StateFields() []string {
	return []string{
		"ICMPv4PacketStats",
		"Invalid",
	}
}

func (i *ICMPv4ReceivedPacketStats) beforeSave() {}

// +checklocksignore
func (i *ICMPv4ReceivedPacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.ICMPv4PacketStats)
	stateSinkObject.Save(1, &i.Invalid)
}

func (i *ICMPv4ReceivedPacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPv4ReceivedPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.ICMPv4PacketStats)
	stateSourceObject.Load(1, &i.Invalid)
}

func (i *ICMPv4Stats) StateTypeName() string {
	return "pkg/tcpip.ICMPv4Stats"
}

func (i *ICMPv4Stats) StateFields() []string {
	return []string{
		"PacketsSent",
		"PacketsReceived",
	}
}

func (i *ICMPv4Stats) beforeSave() {}

// +checklocksignore
func (i *ICMPv4Stats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.PacketsSent)
	stateSinkObject.Save(1, &i.PacketsReceived)
}

func (i *ICMPv4Stats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPv4Stats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.PacketsSent)
	stateSourceObject.Load(1, &i.PacketsReceived)
}

func (i *ICMPv6PacketStats) StateTypeName() string {
	return "pkg/tcpip.ICMPv6PacketStats"
}

func (i *ICMPv6PacketStats) StateFields() []string {
	return []string{
		"EchoRequest",
		"EchoReply",
		"DstUnreachable",
		"PacketTooBig",
		"TimeExceeded",
		"ParamProblem",
		"RouterSolicit",
		"RouterAdvert",
		"NeighborSolicit",
		"NeighborAdvert",
		"RedirectMsg",
		"MulticastListenerQuery",
		"MulticastListenerReport",
		"MulticastListenerReportV2",
		"MulticastListenerDone",
	}
}

func (i *ICMPv6PacketStats) beforeSave() {}

// +checklocksignore
func (i *ICMPv6PacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.EchoRequest)
	stateSinkObject.Save(1, &i.EchoReply)
	stateSinkObject.Save(2, &i.DstUnreachable)
	stateSinkObject.Save(3, &i.PacketTooBig)
	stateSinkObject.Save(4, &i.TimeExceeded)
	stateSinkObject.Save(5, &i.ParamProblem)
	stateSinkObject.Save(6, &i.RouterSolicit)
	stateSinkObject.Save(7, &i.RouterAdvert)
	stateSinkObject.Save(8, &i.NeighborSolicit)
	stateSinkObject.Save(9, &i.NeighborAdvert)
	stateSinkObject.Save(10, &i.RedirectMsg)
	stateSinkObject.Save(11, &i.MulticastListenerQuery)
	stateSinkObject.Save(12, &i.MulticastListenerReport)
	stateSinkObject.Save(13, &i.MulticastListenerReportV2)
	stateSinkObject.Save(14, &i.MulticastListenerDone)
}

func (i *ICMPv6PacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPv6PacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.EchoRequest)
	stateSourceObject.Load(1, &i.EchoReply)
	stateSourceObject.Load(2, &i.DstUnreachable)
	stateSourceObject.Load(3, &i.PacketTooBig)
	stateSourceObject.Load(4, &i.TimeExceeded)
	stateSourceObject.Load(5, &i.ParamProblem)
	stateSourceObject.Load(6, &i.RouterSolicit)
	stateSourceObject.Load(7, &i.RouterAdvert)
	stateSourceObject.Load(8, &i.NeighborSolicit)
	stateSourceObject.Load(9, &i.NeighborAdvert)
	stateSourceObject.Load(10, &i.RedirectMsg)
	stateSourceObject.Load(11, &i.MulticastListenerQuery)
	stateSourceObject.Load(12, &i.MulticastListenerReport)
	stateSourceObject.Load(13, &i.MulticastListenerReportV2)
	stateSourceObject.Load(14, &i.MulticastListenerDone)
}

func (i *ICMPv6SentPacketStats) StateTypeName() string {
	return "pkg/tcpip.ICMPv6SentPacketStats"
}

func (i *ICMPv6SentPacketStats) StateFields() []string {
	return []string{
		"ICMPv6PacketStats",
		"Dropped",
		"RateLimited",
	}
}

func (i *ICMPv6SentPacketStats) beforeSave() {}

// +checklocksignore
func (i *ICMPv6SentPacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.ICMPv6PacketStats)
	stateSinkObject.Save(1, &i.Dropped)
	stateSinkObject.Save(2, &i.RateLimited)
}

func (i *ICMPv6SentPacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPv6SentPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.ICMPv6PacketStats)
	stateSourceObject.Load(1, &i.Dropped)
	stateSourceObject.Load(2, &i.RateLimited)
}

func (i *ICMPv6ReceivedPacketStats) StateTypeName() string {
	return "pkg/tcpip.ICMPv6ReceivedPacketStats"
}

func (i *ICMPv6ReceivedPacketStats) StateFields() []string {
	return []string{
		"ICMPv6PacketStats",
		"Unrecognized",
		"Invalid",
		"RouterOnlyPacketsDroppedByHost",
	}
}

func (i *ICMPv6ReceivedPacketStats) beforeSave() {}

// +checklocksignore
func (i *ICMPv6ReceivedPacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.ICMPv6PacketStats)
	stateSinkObject.Save(1, &i.Unrecognized)
	stateSinkObject.Save(2, &i.Invalid)
	stateSinkObject.Save(3, &i.RouterOnlyPacketsDroppedByHost)
}

func (i *ICMPv6ReceivedPacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPv6ReceivedPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.ICMPv6PacketStats)
	stateSourceObject.Load(1, &i.Unrecognized)
	stateSourceObject.Load(2, &i.Invalid)
	stateSourceObject.Load(3, &i.RouterOnlyPacketsDroppedByHost)
}

func (i *ICMPv6Stats) StateTypeName() string {
	return "pkg/tcpip.ICMPv6Stats"
}

func (i *ICMPv6Stats) StateFields() []string {
	return []string{
		"PacketsSent",
		"PacketsReceived",
	}
}

func (i *ICMPv6Stats) beforeSave() {}

// +checklocksignore
func (i *ICMPv6Stats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.PacketsSent)
	stateSinkObject.Save(1, &i.PacketsReceived)
}

func (i *ICMPv6Stats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPv6Stats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.PacketsSent)
	stateSourceObject.Load(1, &i.PacketsReceived)
}

func (i *ICMPStats) StateTypeName() string {
	return "pkg/tcpip.ICMPStats"
}

func (i *ICMPStats) StateFields() []string {
	return []string{
		"V4",
		"V6",
	}
}

func (i *ICMPStats) beforeSave() {}

// +checklocksignore
func (i *ICMPStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.V4)
	stateSinkObject.Save(1, &i.V6)
}

func (i *ICMPStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *ICMPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.V4)
	stateSourceObject.Load(1, &i.V6)
}

func (i *IGMPPacketStats) StateTypeName() string {
	return "pkg/tcpip.IGMPPacketStats"
}

func (i *IGMPPacketStats) StateFields() []string {
	return []string{
		"MembershipQuery",
		"V1MembershipReport",
		"V2MembershipReport",
		"V3MembershipReport",
		"LeaveGroup",
	}
}

func (i *IGMPPacketStats) beforeSave() {}

// +checklocksignore
func (i *IGMPPacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.MembershipQuery)
	stateSinkObject.Save(1, &i.V1MembershipReport)
	stateSinkObject.Save(2, &i.V2MembershipReport)
	stateSinkObject.Save(3, &i.V3MembershipReport)
	stateSinkObject.Save(4, &i.LeaveGroup)
}

func (i *IGMPPacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *IGMPPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.MembershipQuery)
	stateSourceObject.Load(1, &i.V1MembershipReport)
	stateSourceObject.Load(2, &i.V2MembershipReport)
	stateSourceObject.Load(3, &i.V3MembershipReport)
	stateSourceObject.Load(4, &i.LeaveGroup)
}

func (i *IGMPSentPacketStats) StateTypeName() string {
	return "pkg/tcpip.IGMPSentPacketStats"
}

func (i *IGMPSentPacketStats) StateFields() []string {
	return []string{
		"IGMPPacketStats",
		"Dropped",
	}
}

func (i *IGMPSentPacketStats) beforeSave() {}

// +checklocksignore
func (i *IGMPSentPacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.IGMPPacketStats)
	stateSinkObject.Save(1, &i.Dropped)
}

func (i *IGMPSentPacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *IGMPSentPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.IGMPPacketStats)
	stateSourceObject.Load(1, &i.Dropped)
}

func (i *IGMPReceivedPacketStats) StateTypeName() string {
	return "pkg/tcpip.IGMPReceivedPacketStats"
}

func (i *IGMPReceivedPacketStats) StateFields() []string {
	return []string{
		"IGMPPacketStats",
		"Invalid",
		"ChecksumErrors",
		"Unrecognized",
	}
}

func (i *IGMPReceivedPacketStats) beforeSave() {}

// +checklocksignore
func (i *IGMPReceivedPacketStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.IGMPPacketStats)
	stateSinkObject.Save(1, &i.Invalid)
	stateSinkObject.Save(2, &i.ChecksumErrors)
	stateSinkObject.Save(3, &i.Unrecognized)
}

func (i *IGMPReceivedPacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *IGMPReceivedPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.IGMPPacketStats)
	stateSourceObject.Load(1, &i.Invalid)
	stateSourceObject.Load(2, &i.ChecksumErrors)
	stateSourceObject.Load(3, &i.Unrecognized)
}

func (i *IGMPStats) StateTypeName() string {
	return "pkg/tcpip.IGMPStats"
}

func (i *IGMPStats) StateFields() []string {
	return []string{
		"PacketsSent",
		"PacketsReceived",
	}
}

func (i *IGMPStats) beforeSave() {}

// +checklocksignore
func (i *IGMPStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.PacketsSent)
	stateSinkObject.Save(1, &i.PacketsReceived)
}

func (i *IGMPStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *IGMPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.PacketsSent)
	stateSourceObject.Load(1, &i.PacketsReceived)
}

func (i *IPForwardingStats) StateTypeName() string {
	return "pkg/tcpip.IPForwardingStats"
}

func (i *IPForwardingStats) StateFields() []string {
	return []string{
		"Unrouteable",
		"ExhaustedTTL",
		"InitializingSource",
		"LinkLocalSource",
		"LinkLocalDestination",
		"PacketTooBig",
		"HostUnreachable",
		"ExtensionHeaderProblem",
		"UnexpectedMulticastInputInterface",
		"UnknownOutputEndpoint",
		"NoMulticastPendingQueueBufferSpace",
		"OutgoingDeviceNoBufferSpace",
		"Errors",
		"OutgoingDeviceClosedForSend",
	}
}

func (i *IPForwardingStats) beforeSave() {}

// +checklocksignore
func (i *IPForwardingStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.Unrouteable)
	stateSinkObject.Save(1, &i.ExhaustedTTL)
	stateSinkObject.Save(2, &i.InitializingSource)
	stateSinkObject.Save(3, &i.LinkLocalSource)
	stateSinkObject.Save(4, &i.LinkLocalDestination)
	stateSinkObject.Save(5, &i.PacketTooBig)
	stateSinkObject.Save(6, &i.HostUnreachable)
	stateSinkObject.Save(7, &i.ExtensionHeaderProblem)
	stateSinkObject.Save(8, &i.UnexpectedMulticastInputInterface)
	stateSinkObject.Save(9, &i.UnknownOutputEndpoint)
	stateSinkObject.Save(10, &i.NoMulticastPendingQueueBufferSpace)
	stateSinkObject.Save(11, &i.OutgoingDeviceNoBufferSpace)
	stateSinkObject.Save(12, &i.Errors)
	stateSinkObject.Save(13, &i.OutgoingDeviceClosedForSend)
}

func (i *IPForwardingStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *IPForwardingStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.Unrouteable)
	stateSourceObject.Load(1, &i.ExhaustedTTL)
	stateSourceObject.Load(2, &i.InitializingSource)
	stateSourceObject.Load(3, &i.LinkLocalSource)
	stateSourceObject.Load(4, &i.LinkLocalDestination)
	stateSourceObject.Load(5, &i.PacketTooBig)
	stateSourceObject.Load(6, &i.HostUnreachable)
	stateSourceObject.Load(7, &i.ExtensionHeaderProblem)
	stateSourceObject.Load(8, &i.UnexpectedMulticastInputInterface)
	stateSourceObject.Load(9, &i.UnknownOutputEndpoint)
	stateSourceObject.Load(10, &i.NoMulticastPendingQueueBufferSpace)
	stateSourceObject.Load(11, &i.OutgoingDeviceNoBufferSpace)
	stateSourceObject.Load(12, &i.Errors)
	stateSourceObject.Load(13, &i.OutgoingDeviceClosedForSend)
}

func (i *IPStats) StateTypeName() string {
	return "pkg/tcpip.IPStats"
}

func (i *IPStats) StateFields() []string {
	return []string{
		"PacketsReceived",
		"ValidPacketsReceived",
		"DisabledPacketsReceived",
		"InvalidDestinationAddressesReceived",
		"InvalidSourceAddressesReceived",
		"PacketsDelivered",
		"PacketsSent",
		"OutgoingPacketErrors",
		"MalformedPacketsReceived",
		"MalformedFragmentsReceived",
		"IPTablesPreroutingDropped",
		"IPTablesInputDropped",
		"IPTablesForwardDropped",
		"IPTablesOutputDropped",
		"IPTablesPostroutingDropped",
		"OptionTimestampReceived",
		"OptionRecordRouteReceived",
		"OptionRouterAlertReceived",
		"OptionUnknownReceived",
		"Forwarding",
	}
}

func (i *IPStats) beforeSave() {}

// +checklocksignore
func (i *IPStats) StateSave(stateSinkObject state.Sink) {
	i.beforeSave()
	stateSinkObject.Save(0, &i.PacketsReceived)
	stateSinkObject.Save(1, &i.ValidPacketsReceived)
	stateSinkObject.Save(2, &i.DisabledPacketsReceived)
	stateSinkObject.Save(3, &i.InvalidDestinationAddressesReceived)
	stateSinkObject.Save(4, &i.InvalidSourceAddressesReceived)
	stateSinkObject.Save(5, &i.PacketsDelivered)
	stateSinkObject.Save(6, &i.PacketsSent)
	stateSinkObject.Save(7, &i.OutgoingPacketErrors)
	stateSinkObject.Save(8, &i.MalformedPacketsReceived)
	stateSinkObject.Save(9, &i.MalformedFragmentsReceived)
	stateSinkObject.Save(10, &i.IPTablesPreroutingDropped)
	stateSinkObject.Save(11, &i.IPTablesInputDropped)
	stateSinkObject.Save(12, &i.IPTablesForwardDropped)
	stateSinkObject.Save(13, &i.IPTablesOutputDropped)
	stateSinkObject.Save(14, &i.IPTablesPostroutingDropped)
	stateSinkObject.Save(15, &i.OptionTimestampReceived)
	stateSinkObject.Save(16, &i.OptionRecordRouteReceived)
	stateSinkObject.Save(17, &i.OptionRouterAlertReceived)
	stateSinkObject.Save(18, &i.OptionUnknownReceived)
	stateSinkObject.Save(19, &i.Forwarding)
}

func (i *IPStats) afterLoad(context.Context) {}

// +checklocksignore
func (i *IPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &i.PacketsReceived)
	stateSourceObject.Load(1, &i.ValidPacketsReceived)
	stateSourceObject.Load(2, &i.DisabledPacketsReceived)
	stateSourceObject.Load(3, &i.InvalidDestinationAddressesReceived)
	stateSourceObject.Load(4, &i.InvalidSourceAddressesReceived)
	stateSourceObject.Load(5, &i.PacketsDelivered)
	stateSourceObject.Load(6, &i.PacketsSent)
	stateSourceObject.Load(7, &i.OutgoingPacketErrors)
	stateSourceObject.Load(8, &i.MalformedPacketsReceived)
	stateSourceObject.Load(9, &i.MalformedFragmentsReceived)
	stateSourceObject.Load(10, &i.IPTablesPreroutingDropped)
	stateSourceObject.Load(11, &i.IPTablesInputDropped)
	stateSourceObject.Load(12, &i.IPTablesForwardDropped)
	stateSourceObject.Load(13, &i.IPTablesOutputDropped)
	stateSourceObject.Load(14, &i.IPTablesPostroutingDropped)
	stateSourceObject.Load(15, &i.OptionTimestampReceived)
	stateSourceObject.Load(16, &i.OptionRecordRouteReceived)
	stateSourceObject.Load(17, &i.OptionRouterAlertReceived)
	stateSourceObject.Load(18, &i.OptionUnknownReceived)
	stateSourceObject.Load(19, &i.Forwarding)
}

func (a *ARPStats) StateTypeName() string {
	return "pkg/tcpip.ARPStats"
}

func (a *ARPStats) StateFields() []string {
	return []string{
		"PacketsReceived",
		"DisabledPacketsReceived",
		"MalformedPacketsReceived",
		"RequestsReceived",
		"RequestsReceivedUnknownTargetAddress",
		"OutgoingRequestInterfaceHasNoLocalAddressErrors",
		"OutgoingRequestBadLocalAddressErrors",
		"OutgoingRequestsDropped",
		"OutgoingRequestsSent",
		"RepliesReceived",
		"OutgoingRepliesDropped",
		"OutgoingRepliesSent",
	}
}

func (a *ARPStats) beforeSave() {}

// +checklocksignore
func (a *ARPStats) StateSave(stateSinkObject state.Sink) {
	a.beforeSave()
	stateSinkObject.Save(0, &a.PacketsReceived)
	stateSinkObject.Save(1, &a.DisabledPacketsReceived)
	stateSinkObject.Save(2, &a.MalformedPacketsReceived)
	stateSinkObject.Save(3, &a.RequestsReceived)
	stateSinkObject.Save(4, &a.RequestsReceivedUnknownTargetAddress)
	stateSinkObject.Save(5, &a.OutgoingRequestInterfaceHasNoLocalAddressErrors)
	stateSinkObject.Save(6, &a.OutgoingRequestBadLocalAddressErrors)
	stateSinkObject.Save(7, &a.OutgoingRequestsDropped)
	stateSinkObject.Save(8, &a.OutgoingRequestsSent)
	stateSinkObject.Save(9, &a.RepliesReceived)
	stateSinkObject.Save(10, &a.OutgoingRepliesDropped)
	stateSinkObject.Save(11, &a.OutgoingRepliesSent)
}

func (a *ARPStats) afterLoad(context.Context) {}

// +checklocksignore
func (a *ARPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &a.PacketsReceived)
	stateSourceObject.Load(1, &a.DisabledPacketsReceived)
	stateSourceObject.Load(2, &a.MalformedPacketsReceived)
	stateSourceObject.Load(3, &a.RequestsReceived)
	stateSourceObject.Load(4, &a.RequestsReceivedUnknownTargetAddress)
	stateSourceObject.Load(5, &a.OutgoingRequestInterfaceHasNoLocalAddressErrors)
	stateSourceObject.Load(6, &a.OutgoingRequestBadLocalAddressErrors)
	stateSourceObject.Load(7, &a.OutgoingRequestsDropped)
	stateSourceObject.Load(8, &a.OutgoingRequestsSent)
	stateSourceObject.Load(9, &a.RepliesReceived)
	stateSourceObject.Load(10, &a.OutgoingRepliesDropped)
	stateSourceObject.Load(11, &a.OutgoingRepliesSent)
}

func (t *TCPStats) StateTypeName() string {
	return "pkg/tcpip.TCPStats"
}

func (t *TCPStats) StateFields() []string {
	return []string{
		"ActiveConnectionOpenings",
		"PassiveConnectionOpenings",
		"CurrentEstablished",
		"CurrentConnected",
		"EstablishedResets",
		"EstablishedClosed",
		"EstablishedTimedout",
		"ListenOverflowSynDrop",
		"ListenOverflowAckDrop",
		"ListenOverflowSynCookieSent",
		"ListenOverflowSynCookieRcvd",
		"ListenOverflowInvalidSynCookieRcvd",
		"FailedConnectionAttempts",
		"ValidSegmentsReceived",
		"InvalidSegmentsReceived",
		"SegmentsSent",
		"SegmentSendErrors",
		"ResetsSent",
		"ResetsReceived",
		"Retransmits",
		"FastRecovery",
		"SACKRecovery",
		"TLPRecovery",
		"SlowStartRetransmits",
		"FastRetransmit",
		"Timeouts",
		"ChecksumErrors",
		"FailedPortReservations",
		"SegmentsAckedWithDSACK",
		"SpuriousRecovery",
		"SpuriousRTORecovery",
		"ForwardMaxInFlightDrop",
	}
}

func (t *TCPStats) beforeSave() {}

// +checklocksignore
func (t *TCPStats) StateSave(stateSinkObject state.Sink) {
	t.beforeSave()
	stateSinkObject.Save(0, &t.ActiveConnectionOpenings)
	stateSinkObject.Save(1, &t.PassiveConnectionOpenings)
	stateSinkObject.Save(2, &t.CurrentEstablished)
	stateSinkObject.Save(3, &t.CurrentConnected)
	stateSinkObject.Save(4, &t.EstablishedResets)
	stateSinkObject.Save(5, &t.EstablishedClosed)
	stateSinkObject.Save(6, &t.EstablishedTimedout)
	stateSinkObject.Save(7, &t.ListenOverflowSynDrop)
	stateSinkObject.Save(8, &t.ListenOverflowAckDrop)
	stateSinkObject.Save(9, &t.ListenOverflowSynCookieSent)
	stateSinkObject.Save(10, &t.ListenOverflowSynCookieRcvd)
	stateSinkObject.Save(11, &t.ListenOverflowInvalidSynCookieRcvd)
	stateSinkObject.Save(12, &t.FailedConnectionAttempts)
	stateSinkObject.Save(13, &t.ValidSegmentsReceived)
	stateSinkObject.Save(14, &t.InvalidSegmentsReceived)
	stateSinkObject.Save(15, &t.SegmentsSent)
	stateSinkObject.Save(16, &t.SegmentSendErrors)
	stateSinkObject.Save(17, &t.ResetsSent)
	stateSinkObject.Save(18, &t.ResetsReceived)
	stateSinkObject.Save(19, &t.Retransmits)
	stateSinkObject.Save(20, &t.FastRecovery)
	stateSinkObject.Save(21, &t.SACKRecovery)
	stateSinkObject.Save(22, &t.TLPRecovery)
	stateSinkObject.Save(23, &t.SlowStartRetransmits)
	stateSinkObject.Save(24, &t.FastRetransmit)
	stateSinkObject.Save(25, &t.Timeouts)
	stateSinkObject.Save(26, &t.ChecksumErrors)
	stateSinkObject.Save(27, &t.FailedPortReservations)
	stateSinkObject.Save(28, &t.SegmentsAckedWithDSACK)
	stateSinkObject.Save(29, &t.SpuriousRecovery)
	stateSinkObject.Save(30, &t.SpuriousRTORecovery)
	stateSinkObject.Save(31, &t.ForwardMaxInFlightDrop)
}

func (t *TCPStats) afterLoad(context.Context) {}

// +checklocksignore
func (t *TCPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &t.ActiveConnectionOpenings)
	stateSourceObject.Load(1, &t.PassiveConnectionOpenings)
	stateSourceObject.Load(2, &t.CurrentEstablished)
	stateSourceObject.Load(3, &t.CurrentConnected)
	stateSourceObject.Load(4, &t.EstablishedResets)
	stateSourceObject.Load(5, &t.EstablishedClosed)
	stateSourceObject.Load(6, &t.EstablishedTimedout)
	stateSourceObject.Load(7, &t.ListenOverflowSynDrop)
	stateSourceObject.Load(8, &t.ListenOverflowAckDrop)
	stateSourceObject.Load(9, &t.ListenOverflowSynCookieSent)
	stateSourceObject.Load(10, &t.ListenOverflowSynCookieRcvd)
	stateSourceObject.Load(11, &t.ListenOverflowInvalidSynCookieRcvd)
	stateSourceObject.Load(12, &t.FailedConnectionAttempts)
	stateSourceObject.Load(13, &t.ValidSegmentsReceived)
	stateSourceObject.Load(14, &t.InvalidSegmentsReceived)
	stateSourceObject.Load(15, &t.SegmentsSent)
	stateSourceObject.Load(16, &t.SegmentSendErrors)
	stateSourceObject.Load(17, &t.ResetsSent)
	stateSourceObject.Load(18, &t.ResetsReceived)
	stateSourceObject.Load(19, &t.Retransmits)
	stateSourceObject.Load(20, &t.FastRecovery)
	stateSourceObject.Load(21, &t.SACKRecovery)
	stateSourceObject.Load(22, &t.TLPRecovery)
	stateSourceObject.Load(23, &t.SlowStartRetransmits)
	stateSourceObject.Load(24, &t.FastRetransmit)
	stateSourceObject.Load(25, &t.Timeouts)
	stateSourceObject.Load(26, &t.ChecksumErrors)
	stateSourceObject.Load(27, &t.FailedPortReservations)
	stateSourceObject.Load(28, &t.SegmentsAckedWithDSACK)
	stateSourceObject.Load(29, &t.SpuriousRecovery)
	stateSourceObject.Load(30, &t.SpuriousRTORecovery)
	stateSourceObject.Load(31, &t.ForwardMaxInFlightDrop)
}

func (u *UDPStats) StateTypeName() string {
	return "pkg/tcpip.UDPStats"
}

func (u *UDPStats) StateFields() []string {
	return []string{
		"PacketsReceived",
		"UnknownPortErrors",
		"ReceiveBufferErrors",
		"MalformedPacketsReceived",
		"PacketsSent",
		"PacketSendErrors",
		"ChecksumErrors",
	}
}

func (u *UDPStats) beforeSave() {}

// +checklocksignore
func (u *UDPStats) StateSave(stateSinkObject state.Sink) {
	u.beforeSave()
	stateSinkObject.Save(0, &u.PacketsReceived)
	stateSinkObject.Save(1, &u.UnknownPortErrors)
	stateSinkObject.Save(2, &u.ReceiveBufferErrors)
	stateSinkObject.Save(3, &u.MalformedPacketsReceived)
	stateSinkObject.Save(4, &u.PacketsSent)
	stateSinkObject.Save(5, &u.PacketSendErrors)
	stateSinkObject.Save(6, &u.ChecksumErrors)
}

func (u *UDPStats) afterLoad(context.Context) {}

// +checklocksignore
func (u *UDPStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &u.PacketsReceived)
	stateSourceObject.Load(1, &u.UnknownPortErrors)
	stateSourceObject.Load(2, &u.ReceiveBufferErrors)
	stateSourceObject.Load(3, &u.MalformedPacketsReceived)
	stateSourceObject.Load(4, &u.PacketsSent)
	stateSourceObject.Load(5, &u.PacketSendErrors)
	stateSourceObject.Load(6, &u.ChecksumErrors)
}

func (n *NICNeighborStats) StateTypeName() string {
	return "pkg/tcpip.NICNeighborStats"
}

func (n *NICNeighborStats) StateFields() []string {
	return []string{
		"UnreachableEntryLookups",
		"DroppedConfirmationForNoninitiatedNeighbor",
		"DroppedInvalidLinkAddressConfirmations",
	}
}

func (n *NICNeighborStats) beforeSave() {}

// +checklocksignore
func (n *NICNeighborStats) StateSave(stateSinkObject state.Sink) {
	n.beforeSave()
	stateSinkObject.Save(0, &n.UnreachableEntryLookups)
	stateSinkObject.Save(1, &n.DroppedConfirmationForNoninitiatedNeighbor)
	stateSinkObject.Save(2, &n.DroppedInvalidLinkAddressConfirmations)
}

func (n *NICNeighborStats) afterLoad(context.Context) {}

// +checklocksignore
func (n *NICNeighborStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &n.UnreachableEntryLookups)
	stateSourceObject.Load(1, &n.DroppedConfirmationForNoninitiatedNeighbor)
	stateSourceObject.Load(2, &n.DroppedInvalidLinkAddressConfirmations)
}

func (n *NICPacketStats) StateTypeName() string {
	return "pkg/tcpip.NICPacketStats"
}

func (n *NICPacketStats) StateFields() []string {
	return []string{
		"Packets",
		"Bytes",
	}
}

func (n *NICPacketStats) beforeSave() {}

// +checklocksignore
func (n *NICPacketStats) StateSave(stateSinkObject state.Sink) {
	n.beforeSave()
	stateSinkObject.Save(0, &n.Packets)
	stateSinkObject.Save(1, &n.Bytes)
}

func (n *NICPacketStats) afterLoad(context.Context) {}

// +checklocksignore
func (n *NICPacketStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &n.Packets)
	stateSourceObject.Load(1, &n.Bytes)
}

func (m *IntegralStatCounterMap) StateTypeName() string {
	return "pkg/tcpip.IntegralStatCounterMap"
}

func (m *IntegralStatCounterMap) StateFields() []string {
	return []string{
		"counterMap",
	}
}

func (m *IntegralStatCounterMap) beforeSave() {}

// +checklocksignore
func (m *IntegralStatCounterMap) StateSave(stateSinkObject state.Sink) {
	m.beforeSave()
	stateSinkObject.Save(0, &m.counterMap)
}

func (m *IntegralStatCounterMap) afterLoad(context.Context) {}

// +checklocksignore
func (m *IntegralStatCounterMap) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &m.counterMap)
}

func (m *MultiIntegralStatCounterMap) StateTypeName() string {
	return "pkg/tcpip.MultiIntegralStatCounterMap"
}

func (m *MultiIntegralStatCounterMap) StateFields() []string {
	return []string{
		"a",
		"b",
	}
}

func (m *MultiIntegralStatCounterMap) beforeSave() {}

// +checklocksignore
func (m *MultiIntegralStatCounterMap) StateSave(stateSinkObject state.Sink) {
	m.beforeSave()
	stateSinkObject.Save(0, &m.a)
	stateSinkObject.Save(1, &m.b)
}

func (m *MultiIntegralStatCounterMap) afterLoad(context.Context) {}

// +checklocksignore
func (m *MultiIntegralStatCounterMap) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &m.a)
	stateSourceObject.Load(1, &m.b)
}

func (s *NICStats) StateTypeName() string {
	return "pkg/tcpip.NICStats"
}

func (s *NICStats) StateFields() []string {
	return []string{
		"UnknownL3ProtocolRcvdPacketCounts",
		"UnknownL4ProtocolRcvdPacketCounts",
		"MalformedL4RcvdPackets",
		"Tx",
		"TxPacketsDroppedNoBufferSpace",
		"Rx",
		"DisabledRx",
		"Neighbor",
	}
}

func (s *NICStats) beforeSave() {}

// +checklocksignore
func (s *NICStats) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.UnknownL3ProtocolRcvdPacketCounts)
	stateSinkObject.Save(1, &s.UnknownL4ProtocolRcvdPacketCounts)
	stateSinkObject.Save(2, &s.MalformedL4RcvdPackets)
	stateSinkObject.Save(3, &s.Tx)
	stateSinkObject.Save(4, &s.TxPacketsDroppedNoBufferSpace)
	stateSinkObject.Save(5, &s.Rx)
	stateSinkObject.Save(6, &s.DisabledRx)
	stateSinkObject.Save(7, &s.Neighbor)
}

func (s *NICStats) afterLoad(context.Context) {}

// +checklocksignore
func (s *NICStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.UnknownL3ProtocolRcvdPacketCounts)
	stateSourceObject.Load(1, &s.UnknownL4ProtocolRcvdPacketCounts)
	stateSourceObject.Load(2, &s.MalformedL4RcvdPackets)
	stateSourceObject.Load(3, &s.Tx)
	stateSourceObject.Load(4, &s.TxPacketsDroppedNoBufferSpace)
	stateSourceObject.Load(5, &s.Rx)
	stateSourceObject.Load(6, &s.DisabledRx)
	stateSourceObject.Load(7, &s.Neighbor)
}

func (s *Stats) StateTypeName() string {
	return "pkg/tcpip.Stats"
}

func (s *Stats) StateFields() []string {
	return []string{
		"DroppedPackets",
		"NICs",
		"ICMP",
		"IGMP",
		"IP",
		"ARP",
		"TCP",
		"UDP",
	}
}

func (s *Stats) beforeSave() {}

// +checklocksignore
func (s *Stats) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.DroppedPackets)
	stateSinkObject.Save(1, &s.NICs)
	stateSinkObject.Save(2, &s.ICMP)
	stateSinkObject.Save(3, &s.IGMP)
	stateSinkObject.Save(4, &s.IP)
	stateSinkObject.Save(5, &s.ARP)
	stateSinkObject.Save(6, &s.TCP)
	stateSinkObject.Save(7, &s.UDP)
}

func (s *Stats) afterLoad(context.Context) {}

// +checklocksignore
func (s *Stats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.DroppedPackets)
	stateSourceObject.Load(1, &s.NICs)
	stateSourceObject.Load(2, &s.ICMP)
	stateSourceObject.Load(3, &s.IGMP)
	stateSourceObject.Load(4, &s.IP)
	stateSourceObject.Load(5, &s.ARP)
	stateSourceObject.Load(6, &s.TCP)
	stateSourceObject.Load(7, &s.UDP)
}

func (r *ReceiveErrors) StateTypeName() string {
	return "pkg/tcpip.ReceiveErrors"
}

func (r *ReceiveErrors) StateFields() []string {
	return []string{
		"ReceiveBufferOverflow",
		"MalformedPacketsReceived",
		"ClosedReceiver",
		"ChecksumErrors",
	}
}

func (r *ReceiveErrors) beforeSave() {}

// +checklocksignore
func (r *ReceiveErrors) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.ReceiveBufferOverflow)
	stateSinkObject.Save(1, &r.MalformedPacketsReceived)
	stateSinkObject.Save(2, &r.ClosedReceiver)
	stateSinkObject.Save(3, &r.ChecksumErrors)
}

func (r *ReceiveErrors) afterLoad(context.Context) {}

// +checklocksignore
func (r *ReceiveErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.ReceiveBufferOverflow)
	stateSourceObject.Load(1, &r.MalformedPacketsReceived)
	stateSourceObject.Load(2, &r.ClosedReceiver)
	stateSourceObject.Load(3, &r.ChecksumErrors)
}

func (s *SendErrors) StateTypeName() string {
	return "pkg/tcpip.SendErrors"
}

func (s *SendErrors) StateFields() []string {
	return []string{
		"SendToNetworkFailed",
		"NoRoute",
	}
}

func (s *SendErrors) beforeSave() {}

// +checklocksignore
func (s *SendErrors) StateSave(stateSinkObject state.Sink) {
	s.beforeSave()
	stateSinkObject.Save(0, &s.SendToNetworkFailed)
	stateSinkObject.Save(1, &s.NoRoute)
}

func (s *SendErrors) afterLoad(context.Context) {}

// +checklocksignore
func (s *SendErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &s.SendToNetworkFailed)
	stateSourceObject.Load(1, &s.NoRoute)
}

func (r *ReadErrors) StateTypeName() string {
	return "pkg/tcpip.ReadErrors"
}

func (r *ReadErrors) StateFields() []string {
	return []string{
		"ReadClosed",
		"InvalidEndpointState",
		"NotConnected",
	}
}

func (r *ReadErrors) beforeSave() {}

// +checklocksignore
func (r *ReadErrors) StateSave(stateSinkObject state.Sink) {
	r.beforeSave()
	stateSinkObject.Save(0, &r.ReadClosed)
	stateSinkObject.Save(1, &r.InvalidEndpointState)
	stateSinkObject.Save(2, &r.NotConnected)
}

func (r *ReadErrors) afterLoad(context.Context) {}

// +checklocksignore
func (r *ReadErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &r.ReadClosed)
	stateSourceObject.Load(1, &r.InvalidEndpointState)
	stateSourceObject.Load(2, &r.NotConnected)
}

func (w *WriteErrors) StateTypeName() string {
	return "pkg/tcpip.WriteErrors"
}

func (w *WriteErrors) StateFields() []string {
	return []string{
		"WriteClosed",
		"InvalidEndpointState",
		"InvalidArgs",
	}
}

func (w *WriteErrors) beforeSave() {}

// +checklocksignore
func (w *WriteErrors) StateSave(stateSinkObject state.Sink) {
	w.beforeSave()
	stateSinkObject.Save(0, &w.WriteClosed)
	stateSinkObject.Save(1, &w.InvalidEndpointState)
	stateSinkObject.Save(2, &w.InvalidArgs)
}

func (w *WriteErrors) afterLoad(context.Context) {}

// +checklocksignore
func (w *WriteErrors) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &w.WriteClosed)
	stateSourceObject.Load(1, &w.InvalidEndpointState)
	stateSourceObject.Load(2, &w.InvalidArgs)
}

func (src *TransportEndpointStats) StateTypeName() string {
	return "pkg/tcpip.TransportEndpointStats"
}

func (src *TransportEndpointStats) StateFields() []string {
	return []string{
		"PacketsReceived",
		"PacketsSent",
		"ReceiveErrors",
		"ReadErrors",
		"SendErrors",
		"WriteErrors",
	}
}

func (src *TransportEndpointStats) beforeSave() {}

// +checklocksignore
func (src *TransportEndpointStats) StateSave(stateSinkObject state.Sink) {
	src.beforeSave()
	stateSinkObject.Save(0, &src.PacketsReceived)
	stateSinkObject.Save(1, &src.PacketsSent)
	stateSinkObject.Save(2, &src.ReceiveErrors)
	stateSinkObject.Save(3, &src.ReadErrors)
	stateSinkObject.Save(4, &src.SendErrors)
	stateSinkObject.Save(5, &src.WriteErrors)
}

func (src *TransportEndpointStats) afterLoad(context.Context) {}

// +checklocksignore
func (src *TransportEndpointStats) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &src.PacketsReceived)
	stateSourceObject.Load(1, &src.PacketsSent)
	stateSourceObject.Load(2, &src.ReceiveErrors)
	stateSourceObject.Load(3, &src.ReadErrors)
	stateSourceObject.Load(4, &src.SendErrors)
	stateSourceObject.Load(5, &src.WriteErrors)
}

func (a *AddressWithPrefix) StateTypeName() string {
	return "pkg/tcpip.AddressWithPrefix"
}

func (a *AddressWithPrefix) StateFields() []string {
	return []string{
		"Address",
		"PrefixLen",
	}
}

func (a *AddressWithPrefix) beforeSave() {}

// +checklocksignore
func (a *AddressWithPrefix) StateSave(stateSinkObject state.Sink) {
	a.beforeSave()
	stateSinkObject.Save(0, &a.Address)
	stateSinkObject.Save(1, &a.PrefixLen)
}

func (a *AddressWithPrefix) afterLoad(context.Context) {}

// +checklocksignore
func (a *AddressWithPrefix) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &a.Address)
	stateSourceObject.Load(1, &a.PrefixLen)
}

func (p *ProtocolAddress) StateTypeName() string {
	return "pkg/tcpip.ProtocolAddress"
}

func (p *ProtocolAddress) StateFields() []string {
	return []string{
		"Protocol",
		"AddressWithPrefix",
	}
}

func (p *ProtocolAddress) beforeSave() {}

// +checklocksignore
func (p *ProtocolAddress) StateSave(stateSinkObject state.Sink) {
	p.beforeSave()
	stateSinkObject.Save(0, &p.Protocol)
	stateSinkObject.Save(1, &p.AddressWithPrefix)
}

func (p *ProtocolAddress) afterLoad(context.Context) {}

// +checklocksignore
func (p *ProtocolAddress) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &p.Protocol)
	stateSourceObject.Load(1, &p.AddressWithPrefix)
}

func (j *jobInstance) StateTypeName() string {
	return "pkg/tcpip.jobInstance"
}

func (j *jobInstance) StateFields() []string {
	return []string{
		"timer",
		"earlyReturn",
	}
}

func (j *jobInstance) beforeSave() {}

// +checklocksignore
func (j *jobInstance) StateSave(stateSinkObject state.Sink) {
	j.beforeSave()
	stateSinkObject.Save(0, &j.timer)
	stateSinkObject.Save(1, &j.earlyReturn)
}

func (j *jobInstance) afterLoad(context.Context) {}

// +checklocksignore
func (j *jobInstance) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &j.timer)
	stateSourceObject.Load(1, &j.earlyReturn)
}

func (j *Job) StateTypeName() string {
	return "pkg/tcpip.Job"
}

func (j *Job) StateFields() []string {
	return []string{
		"clock",
		"instance",
	}
}

func (j *Job) beforeSave() {}

// +checklocksignore
func (j *Job) StateSave(stateSinkObject state.Sink) {
	j.beforeSave()
	stateSinkObject.Save(0, &j.clock)
	stateSinkObject.Save(1, &j.instance)
}

func (j *Job) afterLoad(context.Context) {}

// +checklocksignore
func (j *Job) StateLoad(ctx context.Context, stateSourceObject state.Source) {
	stateSourceObject.Load(0, &j.clock)
	stateSourceObject.Load(1, &j.instance)
}

func init() {
	state.Register((*ErrAborted)(nil))
	state.Register((*ErrAddressFamilyNotSupported)(nil))
	state.Register((*ErrAlreadyBound)(nil))
	state.Register((*ErrAlreadyConnected)(nil))
	state.Register((*ErrAlreadyConnecting)(nil))
	state.Register((*ErrBadAddress)(nil))
	state.Register((*ErrBadBuffer)(nil))
	state.Register((*ErrBadLocalAddress)(nil))
	state.Register((*ErrBroadcastDisabled)(nil))
	state.Register((*ErrClosedForReceive)(nil))
	state.Register((*ErrClosedForSend)(nil))
	state.Register((*ErrConnectStarted)(nil))
	state.Register((*ErrConnectionAborted)(nil))
	state.Register((*ErrConnectionRefused)(nil))
	state.Register((*ErrConnectionReset)(nil))
	state.Register((*ErrDestinationRequired)(nil))
	state.Register((*ErrDuplicateAddress)(nil))
	state.Register((*ErrDuplicateNICID)(nil))
	state.Register((*ErrInvalidNICID)(nil))
	state.Register((*ErrInvalidEndpointState)(nil))
	state.Register((*ErrInvalidOptionValue)(nil))
	state.Register((*ErrInvalidPortRange)(nil))
	state.Register((*ErrMalformedHeader)(nil))
	state.Register((*ErrMessageTooLong)(nil))
	state.Register((*ErrNetworkUnreachable)(nil))
	state.Register((*ErrNoBufferSpace)(nil))
	state.Register((*ErrNoPortAvailable)(nil))
	state.Register((*ErrHostUnreachable)(nil))
	state.Register((*ErrHostDown)(nil))
	state.Register((*ErrNoNet)(nil))
	state.Register((*ErrNoSuchFile)(nil))
	state.Register((*ErrNotConnected)(nil))
	state.Register((*ErrNotPermitted)(nil))
	state.Register((*ErrNotSupported)(nil))
	state.Register((*ErrPortInUse)(nil))
	state.Register((*ErrQueueSizeNotSupported)(nil))
	state.Register((*ErrTimeout)(nil))
	state.Register((*ErrUnknownDevice)(nil))
	state.Register((*ErrUnknownNICID)(nil))
	state.Register((*ErrUnknownProtocol)(nil))
	state.Register((*ErrUnknownProtocolOption)(nil))
	state.Register((*ErrWouldBlock)(nil))
	state.Register((*ErrMissingRequiredFields)(nil))
	state.Register((*ErrMulticastInputCannotBeOutput)(nil))
	state.Register((*ErrEndpointBusy)(nil))
	state.Register((*RouteList)(nil))
	state.Register((*RouteEntry)(nil))
	state.Register((*sockErrorList)(nil))
	state.Register((*sockErrorEntry)(nil))
	state.Register((*SocketOptions)(nil))
	state.Register((*LocalSockError)(nil))
	state.Register((*SockError)(nil))
	state.Register((*stdClock)(nil))
	state.Register((*stdTimer)(nil))
	state.Register((*MonotonicTime)(nil))
	state.Register((*Address)(nil))
	state.Register((*AddressMask)(nil))
	state.Register((*Subnet)(nil))
	state.Register((*FullAddress)(nil))
	state.Register((*SendableControlMessages)(nil))
	state.Register((*ReceivableControlMessages)(nil))
	state.Register((*LinkPacketInfo)(nil))
	state.Register((*TCPSendBufferSizeRangeOption)(nil))
	state.Register((*TCPReceiveBufferSizeRangeOption)(nil))
	state.Register((*ICMPv6Filter)(nil))
	state.Register((*TpacketReq)(nil))
	state.Register((*TpacketStats)(nil))
	state.Register((*LingerOption)(nil))
	state.Register((*IPPacketInfo)(nil))
	state.Register((*IPv6PacketInfo)(nil))
	state.Register((*SendBufferSizeOption)(nil))
	state.Register((*ReceiveBufferSizeOption)(nil))
	state.Register((*Route)(nil))
	state.Register((*StatCounter)(nil))
	state.Register((*MultiCounterStat)(nil))
	state.Register((*ICMPv4PacketStats)(nil))
	state.Register((*ICMPv4SentPacketStats)(nil))
	state.Register((*ICMPv4ReceivedPacketStats)(nil))
	state.Register((*ICMPv4Stats)(nil))
	state.Register((*ICMPv6PacketStats)(nil))
	state.Register((*ICMPv6SentPacketStats)(nil))
	state.Register((*ICMPv6ReceivedPacketStats)(nil))
	state.Register((*ICMPv6Stats)(nil))
	state.Register((*ICMPStats)(nil))
	state.Register((*IGMPPacketStats)(nil))
	state.Register((*IGMPSentPacketStats)(nil))
	state.Register((*IGMPReceivedPacketStats)(nil))
	state.Register((*IGMPStats)(nil))
	state.Register((*IPForwardingStats)(nil))
	state.Register((*IPStats)(nil))
	state.Register((*ARPStats)(nil))
	state.Register((*TCPStats)(nil))
	state.Register((*UDPStats)(nil))
	state.Register((*NICNeighborStats)(nil))
	state.Register((*NICPacketStats)(nil))
	state.Register((*IntegralStatCounterMap)(nil))
	state.Register((*MultiIntegralStatCounterMap)(nil))
	state.Register((*NICStats)(nil))
	state.Register((*Stats)(nil))
	state.Register((*ReceiveErrors)(nil))
	state.Register((*SendErrors)(nil))
	state.Register((*ReadErrors)(nil))
	state.Register((*WriteErrors)(nil))
	state.Register((*TransportEndpointStats)(nil))
	state.Register((*AddressWithPrefix)(nil))
	state.Register((*ProtocolAddress)(nil))
	state.Register((*jobInstance)(nil))
	state.Register((*Job)(nil))
}
