func f[P any](T1[P], T2[P]) T3[P]

func (x T[P]) m()
func (T[P]) m(x T[P]) P

func _() {
	type _ []T[P]
	var _ []T[P]
	_ = []T[P]{}

func (x T[P]) m()
func ((T[P])) m(x T[P]) P

func _() {
	type _ []T[P]
	var _ []T[P]
	_ = []T[P]{}

		// Skip leading space at beginning of line.
		blank := true
		for pos < len(p.output) && (p.output[pos] == ' ' || p.output[pos] == '\t') {
			pos++
		}
		// Skip over // comment if any.
		if pos+3 < len(p.output) && p.output[pos] == tabwriter.Escape && p.output[pos+1] == '/' && p.output[pos+2] == '/' {
			blank = false
			for pos < len(p.output) && !isNL(p.output[pos]) {
				pos++
			}
		}
		// Skip over \n at end of line.

func (p *ErrorList) Add(pos token.Position, msg string) {
	*p = append(*p, &Error{pos, msg})
}

// Reset resets an [ErrorList] to no errors.
func (p *ErrorList) Reset() { *p = (*p)[0:0] }

// [ErrorList] implements the sort Interface.
func (p ErrorList) Len() int      { return len(p) }
func (p ErrorList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

func (p ErrorList) Less(i, j int) bool {

package p

func f1[P interface{ *P }]() {}
func f2[P interface{ func(P) }]() {}
func f3[P, Q interface{ func(Q) P }]() {}
func f4[P interface{ *Q }, Q interface{ func(P) }]() {}
func f5[P interface{ func(P) }]() {}
func f6[P interface { *Tree[P] }, Q any ]() {}

func _() {
        f1 /* ERROR "cannot infer P" */ ()
        f2 /* ERROR "cannot infer P" */ ()
        f3 /* ERROR "cannot infer P" */ ()

)

type policyLoadError struct {
	path string
	line int
	data []byte
	err  error
}

func (p policyLoadError) Error() string {
	if p.line >= 0 {
		return fmt.Sprintf("error reading policy file %s, line %d: %s: %v", p.path, p.line, string(p.data), p.err)
	}
	return fmt.Sprintf("error reading policy file %s: %v", p.path, p.err)
}

// PolicyList is simply a slice of Policy structs.
type PolicyList []*abac.Policy

	sink2 = p
	sink2 = unsafe.Slice(p, 100)
}

func CheckPtrStringOK() {
	p := new([4]byte)
	sink2 = unsafe.String(&p[1], 3)
}

func CheckPtrStringFail() {
	p := new(byte)
	sink2 = p
	sink2 = unsafe.String(p, 100)
}

func CheckPtrAlignmentNested() {
	s := make([]int8, 100)
	p := unsafe.Pointer(&s[0])
	n := 9
	_ = ((*[10]int8)(unsafe.Pointer((*[10]int64)(unsafe.Pointer(&p)))))[:n:n]

ip6tables -t raw -A OUTPUT -p udp -j ISTIO_OUTPUT
ip6tables -t nat -A ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 3 -j RETURN
ip6tables -t nat -A ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 4 -j RETURN
ip6tables -t nat -A ISTIO_OUTPUT -p udp --dport 53 -m owner --gid-owner 1 -j RETURN
ip6tables -t nat -A ISTIO_OUTPUT -p udp --dport 53 -m owner --gid-owner 2 -j RETURN

	g[int](x)    // int is ok for P
	g[string](x) // string is also ok for P!
}

// This is analogous to the above example,
// but uses two interface types of the same structure.

type T2[P any] interface{ m() }

func _() {
	var x T2[int]
	g /* ERROR "cannot infer P" */ (x)
	g[int](x)    // int is ok for P
	g[string](x) // string is also ok for P!
}

// Analogous to the T2 example but using an unparameterized interface T3.

// implications on the spec. See issue #51576.

package p

type Sf struct {
        f int
}

func f0[P Sf](p P) {
        _ = p.f // ERROR "p.f undefined"
        p.f /* ERROR "p.f undefined" */ = 0
}

func f0t[P ~struct{f int}](p P) {
        _ = p.f // ERROR "p.f undefined"
        p.f /* ERROR "p.f undefined" */ = 0
}

var _ = f0[Sf]
var _ = f0t[Sf]