p.ptrmap[ptr] = p.line
			p.print(x.Elem())
		}

	case reflect.Array:
		p.printf("%s {", x.Type())
		if x.Len() > 0 {
			p.indent++
			p.printf("\n")
			for i, n := 0, x.Len(); i < n; i++ {
				p.printf("%d: ", i)
				p.print(x.Index(i))
				p.printf("\n")
			}
			p.indent--
		}
		p.printf("}")

	case reflect.Slice:
		if s, ok := x.Interface().([]byte); ok {
			p.printf("%#q", s)

	var tmp ConstPtr2
	p1 := &tmp
	p.c = *p1
	return &p
}

func constptr8() *ConstPtr {
	p := new(ConstPtr) // ERROR "new\(ConstPtr\) escapes to heap"
	var tmp ConstPtr2
	p.c = *&tmp
	return p
}

func constptr9() ConstPtr {
	p := new(ConstPtr) // ERROR "new\(ConstPtr\) does not escape"
	var p1 ConstPtr2
	i := 0 // ERROR "moved to heap: i"
	p1.p = &i
	p.c = p1
	return *p
}

func (p *Process) pidSignal(s syscall.Signal) error {
	if p.Pid == pidUnset {
		return errors.New("os: process not initialized")
	}

	p.sigMu.RLock()
	defer p.sigMu.RUnlock()

	switch p.pidStatus() {
	case statusDone:
		return ErrProcessDone
	case statusReleased:
		return errors.New("os: process already released")
	}

	return convertESRCH(syscall.Kill(p.Pid, s))
}

func convertESRCH(err error) error {

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

package p

import (
	"reflect"
	"unsafe"

	reflect2 "reflect"
)

func sink(e interface{})

func a(hdr *reflect.SliceHeader, p *byte) {
	hdr.Data = uintptr(unsafe.Pointer(p)) // ERROR "write barrier"
}

func b(hdr *reflect.StringHeader, p *byte) {
	hdr.Data = uintptr(unsafe.Pointer(p)) // ERROR "write barrier"
}

iptables -t nat -D OUTPUT -p udp -j ISTIO_OUTPUT
iptables -t raw -D OUTPUT -p udp -j ISTIO_OUTPUT
ip6tables -t nat -D OUTPUT -p udp -j ISTIO_OUTPUT
ip6tables -t raw -D OUTPUT -p udp -j ISTIO_OUTPUT
iptables -t nat -D ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 3 -j RETURN
ip6tables -t nat -D ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 3 -j RETURN
iptables -t nat -D ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 4 -j RETURN

	p.rotationTicker = time.NewTicker(rotationInterval)
	for {
		select {
		case <-p.rotationTicker.C:
			p.rotate()
		case <-p.closing:
			if p.rotationTicker != nil {
				p.rotationTicker.Stop()
			}
			return
		}
	}
}

func (p *GCEPlugin) rotate() {
	if p.shouldRotate(time.Now()) {
		if _, err := p.GetPlatformCredential(); err != nil {

)

func _[P int8 | uint8]() {
	_ = P(0)
	_ = P(1 /* ERROR "constant 255 overflows int8 (in P)" */ <<8 - 1)
}

func _[P int16 | uint16]() {
	_ = P(0)
	_ = P(1 /* ERROR "constant 65535 overflows int16 (in P)" */ <<16 - 1)
}

func _[P int32 | uint32]() {
	_ = P(0)
	_ = P(1 /* ERROR "constant 4294967295 overflows int32 (in P)" */ <<32 - 1)
}

func _[P int64 | uint64]() {
	_ = P(0)

		p(b, "	}\n")
		p(b, "	o.log(`L%ssel bot`)\n", s)
		p(b, "	}\n")
		p(b, "	o.log(`L%ssw bot`)\n", s)
		p(b, "	}\n")
		p(b, "	o.log(`L%sfor bot`)\n", s)
		p(b, "	}\n")
		p(b, "	o.log(`done%s`)\n", s)
		p(b, "goto L%sb; L%sb: o.log(`L%sb`)\n", s, s, s)
	}
	return code
}

var testCode = `
func %s() {
	all := %#v
	for i := 0; i < len(all); i++ {
		c := all[i]
		outFunc := run(%s, c)

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

package p

func f[P any](a, _ P) {
	var x int
	// TODO(gri) these error messages, while correct, could be better
	f(a, x /* ERROR "type int of x does not match inferred type P for P" */)
	f(x, a /* ERROR "type P of a does not match inferred type int for P" */)
}

func g[P any](a, b P) {
	g(a, b)
	g(&a, &b)
	g([]P{}, []P{})

	// work-around: provide type argument explicitly

		if uint64(uintptr(unsafe.Pointer(&p[0])))&uint64(vecAlignMask) != 0 {
			align := uint64(uintptr(unsafe.Pointer(&p[0]))) & uint64(vecAlignMask)
			newlen := vecMinLen - align
			crc = ppc64SlicingUpdateBy8(crc, archCastagnoliTable8, p[:newlen])
			p = p[newlen:]
		}
		// p should be aligned now
		aligned := len(p) & ^vecAlignMask
		crc = vectorCrc32(crc, crcCast, p[:aligned])
		p = p[aligned:]
	}
	if len(p) == 0 {