SYS_MKNODAT                = 4290
	SYS_FCHOWNAT               = 4291
	SYS_FUTIMESAT              = 4292
	SYS_FSTATAT64              = 4293
	SYS_UNLINKAT               = 4294
	SYS_RENAMEAT               = 4295
	SYS_LINKAT                 = 4296
	SYS_SYMLINKAT              = 4297
	SYS_READLINKAT             = 4298
	SYS_FCHMODAT               = 4299
	SYS_FACCESSAT              = 4300

	SYS_FUTIMESAT                    = 4292
	SYS_FSTATAT64                    = 4293
	SYS_UNLINKAT                     = 4294
	SYS_RENAMEAT                     = 4295
	SYS_LINKAT                       = 4296
	SYS_SYMLINKAT                    = 4297
	SYS_READLINKAT                   = 4298
	SYS_FCHMODAT                     = 4299
	SYS_FACCESSAT                    = 4300
	SYS_PSELECT6                     = 4301

	SYS_MKNODAT                = 4290
	SYS_FCHOWNAT               = 4291
	SYS_FUTIMESAT              = 4292
	SYS_FSTATAT64              = 4293
	SYS_UNLINKAT               = 4294
	SYS_RENAMEAT               = 4295
	SYS_LINKAT                 = 4296
	SYS_SYMLINKAT              = 4297
	SYS_READLINKAT             = 4298
	SYS_FCHMODAT               = 4299
	SYS_FACCESSAT              = 4300

	SYS_FUTIMESAT                    = 4292
	SYS_FSTATAT64                    = 4293
	SYS_UNLINKAT                     = 4294
	SYS_RENAMEAT                     = 4295
	SYS_LINKAT                       = 4296
	SYS_SYMLINKAT                    = 4297
	SYS_READLINKAT                   = 4298
	SYS_FCHMODAT                     = 4299
	SYS_FACCESSAT                    = 4300
	SYS_PSELECT6                     = 4301

}

// IsGlobalUnicast reports whether ip is a global unicast
// address.
//
// The identification of global unicast addresses uses address type
// identification as defined in RFC 1122, RFC 4632 and RFC 4291 with
// the exception of IPv4 directed broadcast addresses.
// It returns true even if ip is in IPv4 private address space or
// local IPv6 unicast address space.
func (ip IP) IsGlobalUnicast() bool {

	name  string
	attrs attribute.Set
}

var reg = lazy.New(func() (prometheus.Gatherer, error) {
	// TODO: do not use a global and/or add a way to reset (https://github.com/open-telemetry/opentelemetry-go/issues/4291)
	reg := prometheus.NewRegistry()
	_, err := monitoring.RegisterPrometheusExporter(reg, reg)
	if err != nil {
		return nil, err
	}
	return reg, nil
})

func TestRegistry(t test.Failer) prometheus.Gatherer {

	ipStackCaps.Once.Do(ipStackCaps.probe)
	return ipStackCaps.ipv6Enabled
}

// supportsIPv4map reports whether the platform supports mapping an
// IPv4 address inside an IPv6 address at transport layer
// protocols. See RFC 4291, RFC 4038 and RFC 3493.
func supportsIPv4map() bool {
	// Some operating systems provide no support for mapping IPv4
	// addresses to IPv6, and a runtime check is unnecessary.
	switch runtime.GOOS {

					return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa)
				}
				if ifa.IP.IsLoopback() && prefixLen != 8*IPv6len { // see RFC 4291
					return nil, fmt.Errorf("unexpected prefix length: %d/%d for %#v", prefixLen, maxPrefixLen, ifa)
				}
				stats.ipv6++
			}
		case *IPAddr:
			if ifa == nil || ifa.IP == nil || ifa.IP.IsMulticast() {

		t.Fatal(err)
	}
	if !reflect.DeepEqual(got, []byte("")) {
		t.Errorf(`got %#v, want []byte("")`, got)
	}
}

var ipStringTests = []*struct {
	in  IP     // see RFC 791 and RFC 4291
	str string // see RFC 791, RFC 4291 and RFC 5952
	byt []byte
	error
}{
	// IPv4 address
	{
		IP{192, 0, 2, 1},
		"192.0.2.1",
		[]byte("192.0.2.1"),
		nil,
	},
	{
		IP{0, 0, 0, 0},
		"0.0.0.0",

   *
   * <p>For more on IPv4 compatible addresses see section 2.5.5.1 of <a target="_parent"
   * href="http://tools.ietf.org/html/rfc4291#section-2.5.5.1">RFC 4291</a>.
   *
   * <p>NOTE: This method is different from {@link Inet6Address#isIPv4CompatibleAddress} in that it
   * more correctly classifies {@code "::"} and {@code "::1"} as proper IPv6 addresses (which they