func (ip IP) IsLinkLocalMulticast() bool {
	if ip4 := ip.To4(); ip4 != nil {
		return ip4[0] == 224 && ip4[1] == 0 && ip4[2] == 0
	}
	return len(ip) == IPv6len && ip[0] == 0xff && ip[1]&0x0f == 0x02
}

// IsLinkLocalUnicast reports whether ip is a link-local
// unicast address.
func (ip IP) IsLinkLocalUnicast() bool {
	if ip4 := ip.To4(); ip4 != nil {
		return ip4[0] == 169 && ip4[1] == 254
	}

	d.mptcpStatus.set(use)
}

// Dial connects to the address on the named network.
//
// Known networks are "tcp", "tcp4" (IPv4-only), "tcp6" (IPv6-only),
// "udp", "udp4" (IPv4-only), "udp6" (IPv6-only), "ip", "ip4"
// (IPv4-only), "ip6" (IPv6-only), "unix", "unixgram" and
// "unixpacket".
//
// For TCP and UDP networks, the address has the form "host:port".

		panic("u32 != ju32")
	}
	if u64 != iu64 {
		panic("u64 != iu64")
	}
	if u64 != ju64 {
		panic("u64 != ju64")
	}
	if u128 != iu128 {
		panic("u128 != iu128")
	}
	if u128 != ju128 {
		panic("u128 != ju128")
	}
	if f32 != if32 {
		panic("f32 != if32")
	}
	if f32 != jf32 {
		panic("f32 != jf32")
	}
	if f64 != if64 {
		panic("f64 != if64")
	}
	if f64 != jf64 {

			}
		}
		lits4 = literalAddrs4[:]
	}
	if ip6 != nil {
		for i, lit6 := range literalAddrs6 {
			if strings.Contains(lit6, "%") {
				literalAddrs6[i] = fmt.Sprintf(lit6, ip6[0], ip6[1], ip6[2], ip6[3], ip6[4], ip6[5], ip6[6], ip6[7], ip6[8], ip6[9], ip6[10], ip6[11], ip6[12], ip6[13], ip6[14], ip6[15])
			}
		}
		lits6 = literalAddrs6[:]
	}
	return
}

	litAddrOrName string
	addr          *IPAddr
	err           error
}

var resolveIPAddrTests = []resolveIPAddrTest{
	{"ip", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
	{"ip4", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
	{"ip4:icmp", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
}

func setupTestData() {
	resolveIPAddrTests = append(resolveIPAddrTests,

// license that can be found in the LICENSE file.

package net

import (
	"context"
	"syscall"
)

// BUG(mikio): On every POSIX platform, reads from the "ip4" network
// using the ReadFrom or ReadFromIP method might not return a complete
// IPv4 packet, including its header, even if there is space
// available. This can occur even in cases where Read or ReadMsgIP
// could return a complete packet. For this reason, it is recommended

    }

    return true;
  }

  /**
   * Returns the IPv4 address embedded in an IPv4 compatible address.
   *
   * @param ip {@link Inet6Address} to be examined for an embedded IPv4 address
   * @return {@link Inet4Address} of the embedded IPv4 address
   * @throws IllegalArgumentException if the argument is not a valid IPv4 compatible address
   */

	up64 := (*uint64)(u) // misaligned
	p64 := (*int64)(u)   // misaligned

	shouldPanic(t, "Load64", func() { atomic.Load64(up64) })
	shouldPanic(t, "Loadint64", func() { atomic.Loadint64(p64) })
	shouldPanic(t, "Store64", func() { atomic.Store64(up64, 0) })
	shouldPanic(t, "Xadd64", func() { atomic.Xadd64(up64, 1) })
	shouldPanic(t, "Xchg64", func() { atomic.Xchg64(up64, 1) })

				return nil, syscall.EHOSTUNREACH
			}
		case "udp4":
			if so.Cookie.Family() == syscall.AF_INET && so.Cookie.Type() == syscall.SOCK_DGRAM {
				return nil, syscall.EHOSTUNREACH
			}
		case "ip4":
			if so.Cookie.Family() == syscall.AF_INET && so.Cookie.Type() == syscall.SOCK_RAW {
				return nil, syscall.EHOSTUNREACH
			}
		case "tcp6":

				t.Skip("not supported")
			}
			defer fixup()

			for _, network := range []string{"ip", "ip4", "ip6"} {
				t.Run("network: "+network, func(t *testing.T) {
					switch {
					case network == "ip4" && !v4Ok:
						t.Skip("IPv4 is not supported")
					case network == "ip6" && !v6Ok:
						t.Skip("IPv6 is not supported")
					}

					// google.com has both A and AAAA records.