}

func ExampleIP_IsMulticast() {
	ipv6Multi := net.ParseIP("FF00::")
	ipv6LinkLocalMulti := net.ParseIP("ff02::1")
	ipv6Lo := net.ParseIP("::1")
	ipv4Multi := net.ParseIP("239.0.0.0")
	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
	ipv4Lo := net.ParseIP("127.0.0.0")

	fmt.Println(ipv6Multi.IsMulticast())
	fmt.Println(ipv6LinkLocalMulti.IsMulticast())
	fmt.Println(ipv6Lo.IsMulticast())
	fmt.Println(ipv4Multi.IsMulticast())

apiVersion: release-notes/v2
kind: feature
area: traffic-management
issue:
  - 28003

releaseNotes:
- |

#successRate {
    width: 140px;
    margin-left: 35px;
}

#successRate .percent {
    font-size: 180%;
}

.success, .success a {
    color: #008000;
}

div.success, #successRate.success {
    background-color: #bbd9bb;
    border-color: #008000;
}

.failures, .failures a {
    color: #b60808;
}

.skipped, .skipped a {
    color: #c09853;
}

div.failures, #successRate.failures {

//go:build cgo

package main

import (
	"log"
	"runtime/cgo"
	"unsafe"
)

type S struct{ _ cgo.Incomplete }

func main() {
	p := (*S)(unsafe.Pointer(uintptr(0x8000)))
	var v any = p
	p2 := v.(*S)
	if p != p2 {
		log.Fatalf("%p != %p", unsafe.Pointer(p), unsafe.Pointer(p2))
	}
	p2 = typeAssert[*S](v)
	if p != p2 {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This checks that the -smallframes flag forces a large variable to heap.

package main

const (
	bufferLen = 200000
)

type kbyte []byte
type circularBuffer [bufferLen]kbyte

var sink byte

func main() {
	var c circularBuffer // ERROR "moved to heap: c$"
	sink = c[0][0]

	IMAGE_FILE_NET_RUN_FROM_SWAP       = 0x0800
	IMAGE_FILE_SYSTEM                  = 0x1000
	IMAGE_FILE_DLL                     = 0x2000
	IMAGE_FILE_UP_SYSTEM_ONLY          = 0x4000
	IMAGE_FILE_BYTES_REVERSED_HI       = 0x8000
)

// OptionalHeader64.Subsystem and OptionalHeader32.Subsystem values.
const (
	IMAGE_SUBSYSTEM_UNKNOWN                  = 0
	IMAGE_SUBSYSTEM_NATIVE                   = 1

	Pcsz  uint32 /* size of pc/line number table */
}

// Plan 9 symbol table entries.
type sym struct {
	value uint64
	typ   byte
	name  []byte
}

const (
	Magic64 = 0x8000 // 64-bit expanded header

	Magic386   = (4*11+0)*11 + 7
	MagicAMD64 = (4*26+0)*26 + 7 + Magic64
	MagicARM   = (4*20+0)*20 + 7

		src1 := image.NewRGBA64(image.Rect(0, 0, srcw, srch))
		for y := 0; y < srch; y++ {
			for x := 0; x < srcw; x++ {
				src1.SetRGBA64(x, y, color.RGBA64{
					uint16(103 * x % 0x8000),
					uint16(101 * y % 0x8000),
					uint16((101*x + 103*y) % 0x8000),
					0x7fff,
				})
			}
		}
		src = src1
	case color.NRGBAModel:
		src1 := image.NewNRGBA(image.Rect(0, 0, srcw, srch))
		for y := 0; y < srch; y++ {

)

var invalidStats = ""

var downstreamCxPostiveAcStats = "http.admin.downstream_cx_active: 2 \n" +
	"http.agent.downstream_cx_active: 0 \n" +
	"http.inbound_0.0.0.0_8080.downstream_cx_active: 0 \n" +
	"listener.0.0.0.0_15001.downstream_cx_active: 0 \n" +
	"listener.0.0.0.0_15006.downstream_cx_active: 0 \n" +
	"listener.0.0.0.0_15021.downstream_cx_active: 0 \n" +

			}
			fallthrough
		case "int32":
			inputs = append(inputs, "-0x8000_0000", "-0x7fff_ffff", "-0x12_3456", "0x12_3456", "0x7fff_ffff")
			fallthrough
		case "int16":
			inputs = append(inputs, "-0x8000", "-0x7fff", "-0x1234", "0x1234", "0x7fff")
			fallthrough
		case "int8":
			inputs = append(inputs, "-0x80", "-0x7f", "-0x12", "-1", "0", "1", "0x12", "0x7f")

		case "uint64", "uint", "uintptr":