@font-face {
    font-family: cash-market;
    src: url("https://cash-f.squarecdn.com/static/fonts/cash-market/v2/CashMarket-Regular.woff2") format("woff2");
    font-weight: 400;
    font-style: normal
}

@font-face {
    font-family: cash-market;
    src: url("https://cash-f.squarecdn.com/static/fonts/cash-market/v2/CashMarket-Medium.woff2") format("woff2");
    font-weight: 500;
    font-style: normal
}

@font-face {
    font-family: cash-market;

    /**
     * The Windows operating system family.
     *
     */
    public static final String WINDOWS = "windows";

    /**
     * Is this the Windows operating system family?
     *
     */
    public boolean isWindows() {
        return is(WINDOWS);
    }

    /**
     * The Linux operating system family.
     *
     */
    public static final String LINUX = "linux";

	"syscall"
)

// A sockaddr represents a TCP, UDP, IP or Unix network endpoint
// address that can be converted into a syscall.Sockaddr.
type sockaddr interface {
	Addr

	// family returns the platform-dependent address family
	// identifier.
	family() int

	// isWildcard reports whether the address is a wildcard
	// address.
	isWildcard() bool

	// sockaddr returns the address converted into a syscall

	for _, family := range addressFamilies {
		klog.V(4).Infof("Looking for default routes with IPv%d addresses", uint(family))
		for _, route := range routes {
			if route.Family != family {
				continue
			}
			klog.V(4).Infof("Default route transits interface %q", route.Interface)
			finalIP, err := getIPFromInterface(route.Interface, family, nw)
			if err != nil {
				return nil, err
			}

// NewNodePortAddresses takes an IP family and the `--nodeport-addresses` value (which is
// assumed to contain only valid CIDRs, potentially of both IP families) and returns a
// NodePortAddresses object for the given family. If there are no CIDRs of the given
// family then the CIDR "0.0.0.0/0" or "::/0" will be added (even if there are CIDRs of
// the other family).

		if supportsIPv4map() && fd.laddr.(*TCPAddr).isWildcard() {
			if fd.family != syscall.AF_INET6 {
				return fmt.Errorf("Listen(%s, %v) returns %v; want %v", fd.net, fd.laddr, fd.family, syscall.AF_INET6)
			}
		} else {
			if fd.family != a.family() {
				return fmt.Errorf("Listen(%s, %v) returns %v; want %v", fd.net, fd.laddr, fd.family, a.family())
			}
		}
	case *UDPAddr:

// asynchronous I/O using the network poller.
func socket(ctx context.Context, net string, family, sotype, proto int, ipv6only bool, laddr, raddr sockaddr, ctrlCtxFn func(context.Context, string, string, syscall.RawConn) error) (fd *netFD, err error) {
	s, err := sysSocket(family, sotype, proto)
	if err != nil {
		return nil, err
	}
	if err = setDefaultSockopts(s, family, sotype, ipv6only); err != nil {
		poll.CloseFunc(s)
		return nil, err
	}

    a.sort:visited {
        color: #000000;
    }
    div {
        float: left;
        width: 100px;
        height: 18px;
        padding: 2px;
        font-family: Verdana, sans-serif;
        font-size: 10pt;
    }
    body {
        font-family: Verdana, sans-serif;
        font-size: 10pt;
        background-color: #ffffff;
        margin-top: 0;
        margin-left: 5;
    }
    small {

	os.Exit(st)
}

func TestSwitch(t *testing.T) {
	const N = 10
	var wg sync.WaitGroup
	wg.Add(N)
	for i := 0; i < N; i++ {
		go func() {
			defer wg.Done()
			for _, family := range []int{syscall.AF_INET, syscall.AF_INET6} {
				socketFunc(family, syscall.SOCK_STREAM, syscall.IPPROTO_TCP)
			}
		}()
	}
	wg.Wait()
}

func TestSocket(t *testing.T) {
	for _, f := range []socktest.Filter{

	Pad_cgo_0 [4]byte
}

type RawSockaddrInet4 struct {
	Family uint16
	Port   uint16
	Addr   [4]byte /* in_addr */
	Zero   [8]uint8
}

type RawSockaddrInet6 struct {
	Family   uint16
	Port     uint16
	Flowinfo uint32
	Addr     [16]byte /* in6_addr */
	Scope_id uint32
}

type RawSockaddrUnix struct {
	Family uint16
	Path   [108]int8
}

type RawSockaddrLinklayer struct {