{name: "NEGF", argLength: 1, reg: fp11, asm: "NEGF"},   // -arg0, float32
		{name: "NEGD", argLength: 1, reg: fp11, asm: "NEGD"},   // -arg0, float64
		{name: "ABSD", argLength: 1, reg: fp11, asm: "ABSD"},   // abs(arg0), float64
		{name: "SQRTD", argLength: 1, reg: fp11, asm: "SQRTD"}, // sqrt(arg0), float64
		{name: "SQRTF", argLength: 1, reg: fp11, asm: "SQRTF"}, // sqrt(arg0), float32

		// shifts

        //           for the incorrect optimization in the validType check
        //           (see TODO in validtype.go).
        // T10 interface { T9; T9 }
        // T11 interface { T10; T10 }
        // T12 interface { T11; T11 }
        // T13 interface { T12; T12 }
        // T14 interface { T13; T13 }
        // T15 interface { T14; T14 }
        // T16 interface { T15; T15 }
        // T17 interface { T16; T16 }

  const T9 v9_;
  const T10 v10_;
  const T11 v11_;
};

template <typename T1, typename T2, typename T3, typename T4, typename T5,
    typename T6, typename T7, typename T8, typename T9, typename T10,
    typename T11, typename T12>
class ValueArray12 {
 public:
  ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
      T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),

	P1 *T9
	T9 /* ERROR "invalid recursive type: T9 refers to itself" */ T9

	T10 /* ERROR "invalid recursive type: T10 refers to itself" */ T10
	P2 *T10
)

func (T11) m() {}

type T11 /* ERROR "invalid recursive type: T11 refers to itself" */ struct{ T11 }

type T12 /* ERROR "invalid recursive type: T12 refers to itself" */ struct{ T12 }

func (*T12) m() {}

type (
	P3 *T13

// func f10() {
//	 s := S4{1, 2, 3, 4}
//	 var i I2 = s
//	 i.Put(5)
//	 check(i.Get() == 5, "f10 i")
//	 check(s.l == 4, "f10 s")
// }

func f11() {
	s := S4{1, 2, 3, 4}
	var i I2 = &s
	i.Put(5)
	check(i.Get() == 5, "f11 i")
	check(s.l == 5, "f11 s")
}

func f12() {
	s := &S4{1, 2, 3, 4}
	var i I2 = s
	i.Put(5)
	check(i.Get() == 5, "f12 i")
	check(s.l == 5, "f12 s")
}

		{name: "NEGF", argLength: 1, reg: fp11, asm: "NEGF"},   // -arg0, float32
		{name: "NEGD", argLength: 1, reg: fp11, asm: "NEGD"},   // -arg0, float64
		{name: "SQRTD", argLength: 1, reg: fp11, asm: "SQRTD"}, // sqrt(arg0), float64
		{name: "SQRTF", argLength: 1, reg: fp11, asm: "SQRTF"}, // sqrt(arg0), float32
		{name: "ABSD", argLength: 1, reg: fp11, asm: "ABSD"},   // abs(arg0), float64

	// compute y
	FMOVD	$P5, F8		// F8 = P5
	FMOVD	$P4, F9		// F9 = P4
	FMADDD	F7, F9, F8, F13	// P4+t*P5
	FMOVD	$P3, F10	// F10 = P3
	FMADDD	F7, F10, F13, F13	// P3+t*(P4+t*P5)
	FMOVD	$P2, F11	// F11 = P2
	FMADDD	F7, F11, F13, F13	// P2+t*(P3+t*(P4+t*P5))
	FMOVD	$P1, F12	// F12 = P1
	FMADDD	F7, F12, F13, F13	// P1+t*(P2+t*(P3+t*(P4+t*P5)))
	FMSUBD	F7, F6, F13, F13	// F13 = c = r - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))))
	FMOVD	$2.0, F14

		{name: "LPDFR", argLength: 1, reg: fp11, asm: "LPDFR"},                                                                       // fp64/fp32 set sign bit
		{name: "LNDFR", argLength: 1, reg: fp11, asm: "LNDFR"},                                                                       // fp64/fp32 clear sign bit

	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
	t14 int = i << j
	t15 math /* ERROR "math is not a type" */
	t16 math.xxx /* ERROR "undefined" */
	t17 math /* ERROR "not a type" */ .Pi

		len(a.B.C1.D2.E2.F5) != 0 ||
		len(a.B.C1.D2.E2.F6) != 0 ||
		len(a.B.C1.D2.E2.F7) != 0 ||
		len(a.B.C1.D2.E2.F8) != 0 ||
		len(a.B.C1.D2.E2.F9) != 0 ||
		len(a.B.C1.D2.E2.F10) != 0 ||
		len(a.B.C1.D2.E2.F11) != 0 ||
		len(a.B.C1.D2.E2.F16) != 0 {
		panic("bad")
	}
	C.malloc(100)
}

type A struct {
	B
}

type B struct {
	C1 C
	C2 C
}

type C struct {
	D1 D
	D2 D
}