l0_2 := l0 * 2
	l1_2 := l1 * 2

	l1_38 := l1 * 38
	l2_38 := l2 * 38
	l3_38 := l3 * 38

	l3_19 := l3 * 19
	l4_19 := l4 * 19

	// r0 = l0×l0 + 19×(l1×l4 + l2×l3 + l3×l2 + l4×l1) = l0×l0 + 19×2×(l1×l4 + l2×l3)
	r0 := mul64(l0, l0)
	r0 = addMul64(r0, l1_38, l4)
	r0 = addMul64(r0, l2_38, l3)

	Pragma("noescape")

	a := Dereference(Param("a"))
	l0 := namedComponent{a.Field("l0"), "l0"}
	l1 := namedComponent{a.Field("l1"), "l1"}
	l2 := namedComponent{a.Field("l2"), "l2"}
	l3 := namedComponent{a.Field("l3"), "l3"}
	l4 := namedComponent{a.Field("l4"), "l4"}

	// r0 = l0×l0 + 19×2×(l1×l4 + l2×l3)
	r0 := uint128{"r0", GP64(), GP64()}
	mul64(r0, 1, l0, l0)
	addMul64(r0, 38, l1, l4)
	addMul64(r0, 38, l2, l3)

	x2 = X2(x1) // ERROR "cannot|need type assertion|incompatible"
	x2 = x2

	type L1 []int
	type L2 []NewInt
	var l0 []int
	var l1 L1
	var l2 L2
	l0 = l0
	l0 = l1
	l0 = []int(l2) // ERROR "cannot|invalid"
	l1 = l0
	l1 = l1
	l1 = L1(l2) // ERROR "cannot|invalid"
	l2 = L2(l0) // ERROR "cannot|invalid"
	l2 = L2(l1) // ERROR "cannot|invalid"
	l2 = l2

	type M1 map[string]int

        mv.visitCode();
        Label l0 = new Label();
        mv.visitLabel(l0);
        mv.visitVarInsn(ALOAD, 0);
        mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
        mv.visitInsn(RETURN);
        Label l1 = new Label();
        mv.visitLabel(l1);
        mv.visitLocalVariable("this", "LJavaProbe;", null, l0, l1, 0);
        mv.visitMaxs(1, 1);
        mv.visitEnd();

	MOVQ a+8(FP), CX

	// r0 = l0×l0
	MOVQ (CX), AX
	MULQ (CX)
	MOVQ AX, SI
	MOVQ DX, BX

	// r0 += 38×l1×l4
	MOVQ   8(CX), AX
	IMUL3Q $0x26, AX, AX
	MULQ   32(CX)
	ADDQ   AX, SI
	ADCQ   DX, BX

	// r0 += 38×l2×l3
	MOVQ   16(CX), AX
	IMUL3Q $0x26, AX, AX
	MULQ   24(CX)
	ADDQ   AX, SI
	ADCQ   DX, BX

	// r1 = 2×l0×l1
	MOVQ (CX), AX
	SHLQ $0x01, AX

	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

	// structs
	S0 /* ERROR "invalid recursive type: S0 refers to itself" */ struct{ _ S0 }
	S1 /* ERROR "invalid recursive type: S1 refers to itself" */ struct{ S1 }
	S2 struct{ _ *S2 }
	S3 struct{ *S3 }

nt-style:italic}.typ{color:#404;font-weight:700}.lit{color:#044}.pun,.opn,.clo{color:#440}.tag{color:#006;font-weight:700}.atn{color:#404}.atv{color:#060}}pre.prettyprint{padding:2px;border:1px solid #888}ol.linenums{margin-top:0;margin-bottom:0}li.L0,li.L1,li.L2,li.L3,li.L5,li.L6,li.L7,li.L8{list-style-type:none}li.L1,li.L3,li.L5,li.L7,li.L9{background:#eee}...

	copy(x, y)
	copy(y /* ERROR "expects slice arguments" */ , x)
}

func _[T ~[]byte|~string](x T, y []byte) {
	copy(x /* ERROR "expects slice arguments" */ , y)
	copy(y, x)
}

type L0 []int
type L1 []int

func _[T L0 | L1](x, y T) {
	copy(x, y)
}

// delete

type M0 interface{ int }
type M1 interface{ map[string]int }
type M2 interface { map[string]int | map[string]float64 }

			}
			switch {} // implicit 'true' tag
		}
		`,
		`
		package p
		type S struct{}
		func (T) _() {}
		func (T) _() {}
		`,
		`
		package p
		func _() {
		L0:
		L1:
			goto L0
			for {
				goto L1
			}
			if true {
				goto L2
			}
		L2:
		}
		`,
	}

	pkgnames := []string{
		"fmt",
		"math",
	}

	// parse package files

				_ = x
			}
			switch {} // implicit 'true' tag
		}
		`,
		`
		package p
		type S struct{}
		func (T) _() {}
		func (T) _() {}
		`,
		`
		package p
		func _() {
		L0:
		L1:
			goto L0
			for {
				goto L1
			}
			if true {
				goto L2
			}
		L2:
		}
		`,
	}

	pkgnames := []string{
		"fmt",
		"math",
	}

	// parse package files