T1[P1 any] struct {
		f1 T2[P1, float32]
	}

	T2[P2, P3 any] struct {
		f2 P2
		f3 P3
	}
)

func _() {
	var x1 T1[int]
	var x2 T2[int, float32]

	x1.f1.f2 = 0
	x1.f1 = x2
}

type T3[P any] T1[T2[P, P]]

func _() {
	var x1 T3[int]
	var x2 T2[int, int]
	x1.f1.f2 = x2
}

func f[P any] (x P) List[P] {
	return List[P]{x}
}

var (
	_ []int = f(0)

	CMPL	SI, DI
	JEQ	allsame
	CMPL	BP, $4
	JB	small
#ifdef GO386_softfloat
	JMP	mediumloop
#endif
largeloop:
	CMPL	BP, $16
	JB	mediumloop
	MOVOU	(SI), X0
	MOVOU	(DI), X1
	PCMPEQB X0, X1
	PMOVMSKB X1, BX
	XORL	$0xffff, BX	// convert EQ to NE
	JNE	diff16	// branch if at least one byte is not equal
	ADDL	$16, SI
	ADDL	$16, DI
	SUBL	$16, BP
	JMP	largeloop

diff16:

        registry.versions[1].alias == "group-artifact-x1"
        registry.versions[0].version == "1.1"
        registry.versions[1].version == "1.2"
        registry.libraries[0].alias == "group-artifact"
        registry.libraries[1].alias == "group-artifact-x1"
        registry.libraries[0].versionRef == "group-artifact"
        registry.libraries[1].versionRef == "group-artifact-x1"
    }

    @Unroll

	JNZ   not_aligned

aligned:
	MOVQ $0, AX // position in slices

	PCALIGN $16
loop16b:
	MOVOU (SI)(AX*1), X0   // XOR 16byte forwards.
	MOVOU (CX)(AX*1), X1
	PXOR  X1, X0
	MOVOU X0, (BX)(AX*1)
	ADDQ  $16, AX
	CMPQ  DX, AX
	JNE   loop16b
	RET

	PCALIGN $16
loop_1b:
	SUBQ  $1, DX           // XOR 1byte backwards.
	MOVB  (SI)(DX*1), DI
	MOVB  (CX)(DX*1), AX

go 1.16
-- w2-pre/README.txt --
Package w has been removed.

-- x1/go.mod --
module example.net/x

go 1.16

require (
	example.net/z v0.2.0-pre
	example.net/w v0.2.0-pre
)
-- x1/x.go --
package x
-- x2-pre/go.mod --
module example.net/x

go 1.16
-- x2-pre/README.txt --
Package x has been removed.

-- y1/go.mod --
module example.net/y

go 1.16

		}
	case math.IsInf(re, 0):
		return complex(math.Copysign(math.Pi/2, re), math.Copysign(re, im))
	}
	ct := complex(-imag(x), real(x)) // i * x
	xx := x * x
	x1 := complex(1-real(xx), -imag(xx)) // 1 - x*x
	x2 := Sqrt(x1)                       // x2 = sqrt(1 - x*x)
	w := Log(ct + x2)
	return complex(imag(w), -real(w)) // -i * w
}

// Asinh returns the inverse hyperbolic sine of x.

@composite.Composite('TestNumAttrsOp')
def _tfr_attrs_num_type(x, y, x1, y1):
  # int
  z0 = [x, y]
  z1 = x == y
  z2 = x < y
  z3 = x <= y
  z4 = x > y
  z5 = x >= y
  z6 = x != y
  z7 = x + y
  z8 = x - y
  z8 += x
  z8 += 1
  (z0, z1, z2, z3, z4, z5, z6, z7, z8)  # pylint: disable=pointless-statement

  # float
  z9 = x1 > y1
  z10 = x1 + y1
  z11 = [x1, y1]

	f(b.buf[0 : b.off+m+n])

	signed += ' ' * 8
	tw.octal(header[148:155], chksum)

	_ = x > 0 && i >= 0

	x1, x0 := x>>w2, x&m2
	z0 = t1<<w2 + t0
	z1 = (t1 + t0>>w2) >> w2
	q1, r1 := x1/d1, x1%d1
	r1 = r1*b2 | x0>>w2
	x1 = (x1 << z) | (x0 >> (uint(w) - z))
	x1 = x1<<z | x0>>(uint(w)-z)

	_ = buf[0 : len(buf)+1]
	_ = buf[0 : n+1]

	a, b = b, a
	a = b + c
	a = b*c + d

	f(b.buf[0 : b.off+m+n])

	signed += ' ' * 8
	tw.octal(header[148:155], chksum)

	_ = x > 0 && i >= 0

	x1, x0 := x>>w2, x&m2
	z0 = t1<<w2 + t0
	z1 = (t1 + t0>>w2) >> w2
	q1, r1 := x1/d1, x1%d1
	r1 = r1*b2 | x0>>w2
	x1 = (x1 << z) | (x0 >> (uint(w) - z))
	x1 = x1<<z | x0>>(uint(w)-z)

	_ = buf[0 : len(buf)+1]
	_ = buf[0 : n+1]

	a, b = b, a
	a = b + c
	a = b*c + d

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package issue16153

// original test case
const (
	x1 uint8 = 255
	Y1       = 256
)

// variations
const (
	x2 uint8 = 255
	Y2
)

const (
	X3 int64 = iota
	Y3       = 1
)

const (
	X4 int64 = iota
	Y4