// external services have no instances
	if service.External() {
		return ""
	}
	ipa, ise := netip.ParseAddr(service.DefaultAddress)
	if ise != nil {
		return ""
	}
	ip := ipa.As4()
	ip[2] = byte(1)
	ip[3] = byte(version)
	return netip.AddrFrom4(ip).String()

		return "", fmt.Errorf("netaddr.ParseIP(%q): invalid IP address", orig)
	}
	if strings.Contains(s[i+1:], ".") {
		ip, err := parseIPv4Slow(s[i+1:])
		if err != nil {
			return "", err
		}
		a4 := ip.As4()
		s = fmt.Sprintf("%s:%02x%02x:%02x%02x", s[:i], a4[0], a4[1], a4[2], a4[3])
	}

	// Find and expand a ::, if any.
	fs := strings.Split(s, "::")
	switch len(fs) {
	case 1:
		// No ::, nothing to do.

		if ipa, _ := netip.ParseAddr(host); ipa.IsValid() {
			// Use the 4-byte representation of the IP address when possible.
			ip := ipa.AsSlice()
			if ipa.Is4In6() {
				eip := ipa.As4()
				ip = eip[:]
			}
			ids = append(ids, Identity{Type: TypeIP, Value: ip})
		} else if strings.HasPrefix(host, spiffe.URIPrefix) {
			ids = append(ids, Identity{Type: TypeURI, Value: []byte(host)})
		} else {

	return a16
}

// As4 returns an IPv4 or IPv4-in-IPv6 address in its 4-byte representation.
// If ip is the zero [Addr] or an IPv6 address, As4 panics.
// Note that 0.0.0.0 is not the zero Addr.
func (ip Addr) As4() (a4 [4]byte) {
	if ip.z == z4 || ip.Is4In6() {
		byteorder.BePutUint32(a4[:], uint32(ip.addr.lo))
		return a4
	}
	if ip.z == z0 {
		panic("As4 called on IP zero value")
	}

		},
		{
			ip:        mustIP("::1"),
			wantPanic: true,
		},
	}
	as4 := func(ip Addr) (v [4]byte, gotPanic bool) {
		defer func() {
			if recover() != nil {
				gotPanic = true
				return
			}
		}()
		v = ip.As4()
		return
	}
	for i, tt := range tests {
		got, gotPanic := as4(tt.ip)
		if gotPanic != tt.wantPanic {

	addr := ap.Addr()
	if !addr.Is4() {
		return syscall.SockaddrInet4{}, &AddrError{Err: "non-IPv4 address", Addr: addr.String()}
	}
	sa := syscall.SockaddrInet4{
		Addr: addr.As4(),
		Port: int(ap.Port()),
	}
	return sa, nil
}

func addrPortToSockaddrInet6(ap netip.AddrPort) (syscall.SockaddrInet6, error) {
	// ipToSockaddrInet6 has special handling here for zero length slices.

pkg net/netip, method (*Prefix) UnmarshalText([]uint8) error
pkg net/netip, method (Addr) AppendTo([]uint8) []uint8
pkg net/netip, method (Addr) As16() [16]uint8
pkg net/netip, method (Addr) As4() [4]uint8
pkg net/netip, method (Addr) AsSlice() []uint8
pkg net/netip, method (Addr) BitLen() int
pkg net/netip, method (Addr) Compare(Addr) int
pkg net/netip, method (Addr) Is4() bool

		{"(*AddrPort).UnmarshalText", Method, 18},
		{"(*Prefix).UnmarshalBinary", Method, 18},
		{"(*Prefix).UnmarshalText", Method, 18},
		{"(Addr).AppendTo", Method, 18},
		{"(Addr).As16", Method, 18},
		{"(Addr).As4", Method, 18},
		{"(Addr).AsSlice", Method, 18},
		{"(Addr).BitLen", Method, 18},
		{"(Addr).Compare", Method, 18},
		{"(Addr).Is4", Method, 18},
		{"(Addr).Is4In6", Method, 18},
		{"(Addr).Is6", Method, 18},