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 {

		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

   *
   * <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

// link-local address space. It also returns true even if ip is in the IPv4
// private address space or IPv6 unique local address space.
// It returns false for the zero [Addr].
//
// For reference, see RFC 1122, RFC 4291, and RFC 4632.
func (ip Addr) IsGlobalUnicast() bool {
	if ip.z == z0 {
		// Invalid or zero-value.
		return false
	}

	if ip.Is4In6() {
		ip = ip.Unmap()
	}

	{"net.inet.etherip.allow", []_C_int{4, 2, 97, 1}},
	{"net.inet.etherip.stats", []_C_int{4, 2, 97, 2}},
	{"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}},