{"net.inet.gre.allow", []_C_int{4, 2, 47, 1}},
	{"net.inet.gre.wccp", []_C_int{4, 2, 47, 2}},
	{"net.inet.icmp.bmcastecho", []_C_int{4, 2, 1, 2}},
	{"net.inet.icmp.errppslimit", []_C_int{4, 2, 1, 3}},
	{"net.inet.icmp.maskrepl", []_C_int{4, 2, 1, 1}},
	{"net.inet.icmp.rediraccept", []_C_int{4, 2, 1, 4}},
	{"net.inet.icmp.redirtimeout", []_C_int{4, 2, 1, 5}},
	{"net.inet.icmp.stats", []_C_int{4, 2, 1, 7}},

	{"net.inet.gre.allow", []_C_int{4, 2, 47, 1}},
	{"net.inet.gre.wccp", []_C_int{4, 2, 47, 2}},
	{"net.inet.icmp.bmcastecho", []_C_int{4, 2, 1, 2}},
	{"net.inet.icmp.errppslimit", []_C_int{4, 2, 1, 3}},
	{"net.inet.icmp.maskrepl", []_C_int{4, 2, 1, 1}},
	{"net.inet.icmp.rediraccept", []_C_int{4, 2, 1, 4}},
	{"net.inet.icmp.redirtimeout", []_C_int{4, 2, 1, 5}},
	{"net.inet.icmp.stats", []_C_int{4, 2, 1, 7}},

		},
		Spec: net.IngressSpec{
			Rules: []net.IngressRule{
				{
					Host: "my.host.com",
					IngressRuleValue: net.IngressRuleValue{
						HTTP: &net.HTTPIngressRuleValue{
							Paths: []net.HTTPIngressPath{
								{
									Path: "/test2",
									Backend: net.IngressBackend{
										Service: &net.IngressServiceBackend{
											Name: "foo",
											Port: net.ServiceBackendPort{

pkg net/netip, func AddrFrom4([4]uint8) Addr
pkg net/netip, func AddrFromSlice([]uint8) (Addr, bool)
pkg net/netip, func AddrPortFrom(Addr, uint16) AddrPort
pkg net/netip, func IPv4Unspecified() Addr
pkg net/netip, func IPv6LinkLocalAllNodes() Addr
pkg net/netip, func IPv6Unspecified() Addr
pkg net/netip, func MustParseAddr(string) Addr
pkg net/netip, func MustParseAddrPort(string) AddrPort
pkg net/netip, func MustParsePrefix(string) Prefix

	math/rand !< net; # net uses runtime instead

	# NET is net plus net-helper packages.
	FMT, net
	< net/textproto;

	mime, net/textproto, net/url
	< NET;

	# logging - most packages should not import; http and up is allowed
	FMT, log/internal
	< log;

	log, log/slog !< crypto/tls, database/sql, go/importer, testing;

	FMT, log, net
	< log/syslog;

	RUNTIME

	if b[2] != 0 {
		return nil, errors.New("non-zero reserved field")
	}
	l := 2
	var a socksAddr
	switch b[3] {
	case socksAddrTypeIPv4:
		l += net.IPv4len
		a.IP = make(net.IP, net.IPv4len)
	case socksAddrTypeIPv6:
		l += net.IPv6len
		a.IP = make(net.IP, net.IPv6len)
	case socksAddrTypeFQDN:
		if _, err := io.ReadFull(c, b[:1]); err != nil {
			return nil, err
		}
		l += int(b[0])
	default:

	if err != nil {
		err = &OpError{Op: "write", Net: c.fd.net, Source: c.fd.laddr, Addr: addr.opAddr(), Err: err}
	}
	return n, err
}

// WriteTo implements the [PacketConn] WriteTo method.
func (c *UnixConn) WriteTo(b []byte, addr Addr) (int, error) {
	if !c.ok() {
		return 0, syscall.EINVAL
	}
	a, ok := addr.(*UnixAddr)
	if !ok {

// wrapping the underlying net library function calls.
type networkInterface struct{}

func (_ networkInterface) InterfaceByName(intfName string) (*net.Interface, error) {
	return net.InterfaceByName(intfName)
}

func (_ networkInterface) Addrs(intf *net.Interface) ([]net.Addr, error) {
	return intf.Addrs()
}

func (_ networkInterface) Interfaces() ([]net.Interface, error) {
	return net.Interfaces()
}

func (r *Range) Restore(net *net.IPNet, data []byte) error {
	if !net.IP.Equal(r.net.IP) || net.Mask.String() != r.net.Mask.String() {
		return ErrMismatchedNetwork
	}
	snapshottable, ok := r.alloc.(allocator.Snapshottable)
	if !ok {
		return fmt.Errorf("not a snapshottable allocator")
	}
	if err := snapshottable.Restore(net.String(), data); err != nil {

					},
				},
				Clientset: fake.NewSimpleClientset(),
			},
			allocatorParams: CIDRAllocatorParams{
				ClusterCIDRs: func() []*net.IPNet {
					_, clusterCIDR, _ := netutils.ParseCIDRSloppy("127.123.234.0/24")
					return []*net.IPNet{clusterCIDR}
				}(),
				ServiceCIDR: func() *net.IPNet {
					_, serviceCIDR, _ := netutils.ParseCIDRSloppy("127.123.234.0/26")
					return serviceCIDR
				}(),