g.p("\n")
	}
	g.p(")\n\n")
}

func (g *gen) product(n int) {
	g.p(`// Product matrix
const (
`)
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			g.p("\tp%d_%d = ", i, j)
			for k := 0; k < n; k++ {
				if k > 0 {
					g.p(" + ")
				}
				g.p("h%d_%d*i%d_%d", i, k, k, j)
			}
			g.p("\n")
		}
		g.p("\n")
	}
	g.p(")\n\n")
}

func (g *gen) verify(n int) {

	{"package p; type _[P (T),] struct{}", "package p; type _[P T] struct{}"},
	{"package p; type _[P (T), _ any] struct{}", "package p; type _[P T, _ any] struct{}"},

	{"package p; type _[P (*struct{})] struct{}", "package p; type _[P *struct{}] struct{}"},
	{"package p; type _[P ([]int)] struct{}", "package p; type _[P []int] struct{}"},

}

func (in *input) _byte(p int) byte {
	if in.bytes == nil {
		return in.str[p]
	}
	return in.bytes[p]
}

func (in *input) skipASCII(p, max int) int {
	if in.bytes == nil {
		for ; p < max && in.str[p] < utf8.RuneSelf; p++ {
		}
	} else {
		for ; p < max && in.bytes[p] < utf8.RuneSelf; p++ {
		}
	}
	return p
}

func (in *input) skipContinuationBytes(p int) int {
	if in.bytes == nil {

            assertThat(p, nullValue())
        }

        withMockForProject(existing = "p" to null) {

            val p: Int? by project
            assertThat(p, nullValue())
        }
    }

    @Test
    fun `nullable delegated property access of non-existing gradle property`() {

        withMockForSettings(absent = "p") {

            val p: Int? by settings

func (p *ProcessState) Pid() int {
	return p.pid
}

func (p *ProcessState) exited() bool {
	return p.status.Exited()
}

func (p *ProcessState) success() bool {
	return p.status.ExitStatus() == 0
}

func (p *ProcessState) sys() any {
	return p.status
}

func (p *ProcessState) sysUsage() any {
	return p.status
}

package p

// The example from the issue.
type (
	N[P any] M /* ERROR "invalid recursive type" */ [P]
	M[P any] N[P]
)

// A slightly more complicated case.
type (
	A[P any] B /* ERROR "invalid recursive type" */ [P]
	B[P any] C[P]
	C[P any] A[P]
)

// Confusing but valid (note that `type T *T` is valid).
type (
	N1[P any] *M1[P]
	M1[P any] *N1[P]

	example.net/m v0.2.0 => ./m2
	example.net/m/p v1.0.0 => ./p0
)
-- importer.go --
package importer
import _ "example.net/m/p"
-- m1/go.mod --
module example.net/m

go 1.16
-- m1/p/p.go --
package p
-- m2/go.mod --
module example.net/m

go 1.16
-- m2/README.txt --
Package p has been moved to module …/m/p.
Module …/m/p does not require any version of module …/m.

-- p0/go.mod --

	return hypot(p, q)
}

func hypot(p, q float64) float64 {
	p, q = Abs(p), Abs(q)
	// special cases
	switch {
	case IsInf(p, 1) || IsInf(q, 1):
		return Inf(1)
	case IsNaN(p) || IsNaN(q):
		return NaN()
	}
	if p < q {
		p, q = q, p
	}
	if p == 0 {
		return 0
	}
	q = q / p
	return p * Sqrt(1+q*q)

		panic("FAIL")
	}
	if &y != p {
		print("&y=", &y, " p=", p, " &y==p = ", &y==p, "\n")
		panic("FAIL")
	}

	x := 0
	p := &x
	_ = func(p **int) *int { // ERROR "leaking param: p to result ~r0 level=1" "func literal does not escape"
		return *p
	}(&p)
}

func ClosureCallArgs15() {
	x := 0 // ERROR "moved to heap: x"
	p := &x
	sink = func(p **int) *int { // ERROR "leaking param content: p" "func literal does not escape"
		return *p
	}(&p)
}

func ClosureLeak1(s string) string { // ERROR "s does not escape"