func NopConvertGeneric[T any](x T) T {
	// amd64:-`.*runtime.convI2I`
	return T(x)
}

var NopConvertGenericIface = NopConvertGeneric[I]

func ConvToM(x any) I {
	// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(.*\)`,`MOVQ\t8\(.*\)(.*\*1)`
	// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU`,`MOVD\t\(R.*\)\(R.*\)`
	return x.(I)

}

type T1 struct {
	X *int
}

func f15(x []T1, y T1) []T1 {
	return append(x, y) // ERROR "write barrier"
}

type T8 struct {
	X [8]*int
}

func f16(x []T8, y T8) []T8 {
	return append(x, y) // ERROR "write barrier"
}

func t1(i interface{}) **int {
	// From issue 14306, make sure we have write barriers in a type switch

package cycles

import "unsafe"

type (
	T0 int
	T1 /* ERROR "invalid recursive type: T1 refers to itself" */ T1
	T2 *T2

	T3 /* ERROR "invalid recursive type" */ T4
	T4 T5
	T5 T3

	T6 T7
	T7 *T8
	T8 T6

	// arrays
	A0 /* ERROR "invalid recursive type" */ [10]A0
	A1 [10]*A1

	A2 /* ERROR "invalid recursive type" */ [10]A3
	A3 [10]A4
	A4 A2

	A5 [10]A6
	A6 *A5

	// slices
	L0 []L0

			Valu("t6", OpMod64, c.config.Types.Int64, 0, nil, "t5", "v2"),
			Valu("t7", OpAnd64, c.config.Types.Int64, 0, nil, "t6", "v2"),
			Valu("t8", OpOr64, c.config.Types.Int64, 0, nil, "t7", "v2"),
			Valu("t9", OpXor64, c.config.Types.Int64, 0, nil, "t8", "v2"),
			Valu("t10", OpNeg64, c.config.Types.Int64, 0, nil, "t9"),
			Valu("t11", OpCom64, c.config.Types.Int64, 0, nil, "t10"),

func (TS) Method1() {}
func (TS) Method2() {}
func (TM) Method1() {}
func (TM) Method2() {}
func (TL) Method1() {}
func (TL) Method2() {}

type T8 uint8
type T16 uint16
type T32 uint32
type T64 uint64
type Tstr string
type Tslice []byte

func (T8) Method1()     {}
func (T16) Method1()    {}
func (T32) Method1()    {}
func (T64) Method1()    {}
func (Tstr) Method1()   {}
func (Tslice) Method1() {}

	t3 int = c /* ERRORx `cannot use .* variable declaration` */ + d
	t4 string = s + t
	t5 string = s /* ERROR "invalid operation" */ / t
	t6 byte = array[t1]
	t7 byte = array[x /* ERROR "must be integer" */]
	t8 *int = & /* ERRORx `cannot use .* variable declaration` */ a
	t10 *int = &42 /* ERROR "cannot take address" */
	t11 *complex64 = &v
	t12 complex64 = -(u + *t11) / *&v
	t13 int = a /* ERROR "shifted operand" */ << d

}

func copyPPC64x(w io.Writer) {
	// duffcopy is not used on PPC64.
	fmt.Fprintln(w, "TEXT runtime·duffcopy<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0")
	for i := 0; i < 128; i++ {
		fmt.Fprintln(w, "\tMOVDU\t8(R20), R5")
		fmt.Fprintln(w, "\tMOVDU\tR5, 8(R21)")
	}
	fmt.Fprintln(w, "\tRET")
}

func tagsMIPS64x(w io.Writer) {
	fmt.Fprintln(w)
	fmt.Fprintln(w, "//go:build mips64 || mips64le")
	fmt.Fprintln(w)