i := 0 // ERROR "moved to heap: i$"
	var p *int
	param2(&i, &p)
	_ = p
}

func caller2b() {
	i := 0 // ERROR "moved to heap: i$"
	var p *int
	param2(&i, &p)
	sink = p
}

func paramArraySelfAssign(p *PairOfPairs) { // ERROR "p does not escape"
	p.pairs[0] = p.pairs[1] // ERROR "ignoring self-assignment in p.pairs\[0\] = p.pairs\[1\]"
}

// from assigning the functions.

package p

func f1[P any](P)        {}
func f2[P any]() P       { var x P; return x }
func f3[P, Q any](P) Q   { var x Q; return x }
func f4[P any](P, P)     {}
func f5[P any](P) []P    { return nil }
func f6[P any](int) P    { var x P; return x }
func f7[P any](P) string { return "" }

// initialization expressions
var (

	P *[]int
}

func test2() {
	var all []T
	for i := 0; i < 100; i++ {
		p := new([]int)
		*p = append(*p, 1, 2, 3, 4)
		h := (*reflect.SliceHeader)(unsafe.Pointer(p))
		all = append(all, T{H: h}, T{P: p})
	}
	runtime.GC()
	for i := 0; i < 100; i++ {
		p := *all[2*i+1].P
		if p[0] != 1 || p[1] != 2 || p[2] != 3 || p[3] != 4 {
			println("BUG test2: bad slice at index", i, p[0], p[1], p[2], p[3])
			return

func f3(func() func() int)

func main() {
	p.F3(p.F1)
	p.F3(p.F2())
	f3(p.F1)
	f3(p.F2())

	p.C1 = (chan<- (chan int))(nil)
	p.C2 = (chan (<-chan int))(nil)
	p.C3 = (<-chan (chan int))(nil)
	p.C4 = (chan (chan<- int))(nil)

	p.C5 = (<-chan (<-chan int))(nil)
	p.C6 = (chan<- (<-chan int))(nil)
	p.C7 = (chan<- (chan<- int))(nil)

	p.C8 = (<-chan (<-chan (chan int)))(nil)
	p.C9 = (<-chan (chan<- (chan int)))(nil)

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

package p

// indirection

func _[P any](p P) {
        _ = *p // ERROR "cannot indirect p"
}

func _[P interface{ int }](p P) {
        _ = *p // ERROR "cannot indirect p"
}

func _[P interface{ *int }](p P) {
        _ = *p
}

func _[P interface{ *int | *string }](p P) {
        _ = *p // ERROR "must have identical base types"
}

type intPtr *int

}

func (p *YCbCr) YCbCrAt(x, y int) color.YCbCr {
	if !(Point{x, y}.In(p.Rect)) {
		return color.YCbCr{}
	}
	yi := p.YOffset(x, y)
	ci := p.COffset(x, y)
	return color.YCbCr{
		p.Y[yi],
		p.Cb[ci],
		p.Cr[ci],
	}
}

// YOffset returns the index of the first element of Y that corresponds to
// the pixel at (x, y).
func (p *YCbCr) YOffset(x, y int) int {
	return (y-p.Rect.Min.Y)*p.YStride + (x - p.Rect.Min.X)
}

        this.idleTimeoutDisabled = Config.getBoolean(p, "jcifs.smb.client.disableIdleTimeout", false);

        this.smbLocalAddress = Config.getLocalHost(p);
        this.smbLocalPort = Config.getInt(p, "jcifs.smb.client.lport", 0);
        this.maxMpxCount = Config.getInt(p, "jcifs.smb.client.maxMpxCount", SmbConstants.DEFAULT_MAX_MPX_COUNT);

	v.V()

	//	p = t	// ERROR
	var i interface{} = t
	if _, ok := i.(P); ok {
		println("dynamic i.(P) succeeded incorrectly")
		panic("fail")
	}

	//	println("--struct--");
	var s S
	s.T = 42
	s.P()
	s.V()

	v = s
	s.V()

	p = &s
	p.P()
	p.V()

	v = &s
	v.V()

	//	p = s	// ERROR
	var j interface{} = s
	if _, ok := j.(P); ok {
		println("dynamic j.(P) succeeded incorrectly")

func (p XPos) After(q XPos) bool {
	n, m := p.index, q.index
	return n > m || n == m && p.lico > q.lico
}

// WithNotStmt returns the same location to be marked with DWARF is_stmt=0
func (p XPos) WithNotStmt() XPos {
	p.lico = p.lico.withNotStmt()
	return p
}

// WithDefaultStmt returns the same location with undetermined is_stmt
func (p XPos) WithDefaultStmt() XPos {
	p.lico = p.lico.withDefaultStmt()

func (p *printer) newline() {
	if len(p.comment) > 0 {
		p.printf(" ")
		for i, com := range p.comment {
			if i > 0 {
				p.trim()
				p.printf("\n")
				for i := 0; i < p.margin; i++ {
					p.printf("\t")
				}
			}
			p.printf("%s", strings.TrimSpace(com.Token))
		}
		p.comment = p.comment[:0]
	}

	p.trim()