package p

import "unsafe"

// The actual example from the issue.
type List[P any] struct{}

func (_ List[P]) m() (_ List[List[P]]) { return }

// Other types of recursion through methods.
type R[P any] int

func (*R[R /* ERROR "must be an identifier" */ [int]]) m0() {}
func (R[P]) m1(R[R[P]])                                   {}
func (R[P]) m2(R[*P])                                     {}

			if p.labels[label] != nil {
				p.errorf("label %q multiply defined", label)
				return
			}
			p.labels[label] = prog
		}
		p.pendingLabels = p.pendingLabels[0:0]
	}
	prog.Pc = p.pc
	if *flags.Debug {
		fmt.Println(p.lineNum, prog)
	}
	if testOut != nil {
		fmt.Fprintln(testOut, prog)
	}
}

// validSymbol checks that addr represents a valid name for a pseudo-op.

			p.As = AORI
		case AXOR:
			p.As = AXORI
		case ASLL:
			p.As = ASLLI
		case ASRL:
			p.As = ASRLI
		case ASRA:
			p.As = ASRAI
		case AADDW:
			p.As = AADDIW
		case ASUBW:
			p.As, p.From.Offset = AADDIW, -p.From.Offset
		case ASLLW:
			p.As = ASLLIW
		case ASRLW:
			p.As = ASRLIW
		case ASRAW:
			p.As = ASRAIW
		case AROR:
			p.As = ARORI
		case ARORW:
			p.As = ARORIW

	p.Pc = pc
	var m int
	var o *Optab
	for p = p.Link; p != nil; p = p.Link {
		p.Pc = pc
		o = c.oplook(p)
		m = o.size(c.ctxt, p)
		if m == 0 {
			switch p.As {
			case obj.APCALIGN, obj.APCALIGNMAX:
				m = obj.AlignmentPadding(int32(pc), p, ctxt, cursym)
				break
			case obj.ANOP, obj.AFUNCDATA, obj.APCDATA:
				continue
			default:
				c.ctxt.Diag("zero-width instruction\n%v", p)
			}

}

// Obj returns the inner Pod.
func (p *PodWrapper) Obj() *v1.Pod {
	return &p.Pod
}

// Name sets `s` as the name of the inner pod.
func (p *PodWrapper) Name(s string) *PodWrapper {
	p.SetName(s)
	return p
}

// UID sets `s` as the UID of the inner pod.
func (p *PodWrapper) UID(s string) *PodWrapper {
	p.SetUID(types.UID(s))
	return p
}

iptables -t nat -A ISTIO_OUTPUT -p udp --dport 53 -m owner --gid-owner 2 -j RETURN
iptables -t nat -A ISTIO_OUTPUT -p udp --dport 53 -d 127.0.0.53/32 -j REDIRECT --to-port 15053
iptables -t raw -A ISTIO_OUTPUT -p udp --dport 53 -m owner --uid-owner 3 -j CT --zone 1
iptables -t raw -A ISTIO_OUTPUT -p udp --sport 15053 -m owner --uid-owner 3 -j CT --zone 2

}

//go:noinline
func f() {
	var t [1]int // non-empty frame
	*(*int)(nil) = t[0]
}

var p = funcPC(runtime.GC) + 8

//go:noinline
func prep() {
	// put some garbage on stack
	var x = [20]uintptr{p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p}
	_ = x

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]{}
}

// type constraint literals with elided interfaces
func _[P ~int, Q int | string]()	{}
func _[P struct{ f int }, Q *P]()	{}

// various potentially ambiguous type parameter lists (issue #49482)
type _[P *T,] struct{}
type _[P T | T] struct{}
type _[P T | T | T | T] struct{}

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

package p

func f1(func(int))
func f2(func(int), func(string))
func f3(func(int), func(string), func(float32))

func g1[P any](P) {}

func _() {
	f1(g1)
	f2(g1, g1)
	f3(g1, g1, g1)
}

// More complex examples

func g2[P any](P, P)                                         {}
func h3[P any](func(P), func(P), func() P)                   {}

replace (
	example.com/p => ../p
	example.com/q => ../q
)
-- b/b.go --
package b

import (
	"example.com/p"
	"example.com/q"
)

func Foo() {
	p.P()
	q.Q()
}
-- p/go.mod --
go 1.18

module example.com/p
-- p/p.go --
package p

func P() {}
-- q/go.mod --
go 1.18

module example.com/q
-- q/q.go --
package q

func Q() {}
-- r/go.mod --
go 1.18