type I012 interface {
	E0
	E1
	E2
}

func f012[T I012]() {}
var _ = f012[int /* ERRORx `cannot satisfy I012.*empty type set` */ ]
var _ = f012[bool /* ERRORx `cannot satisfy I012.*empty type set` */ ]
var _ = f012[string /* ERRORx `cannot satisfy I012.*empty type set` */ ]
var _ = f012[float64 /* ERRORx `cannot satisfy I012.*empty type set` */ ]

type I12 interface {
	E1
	E2

	ch6 = *ch5
	ch7 = <-ch
	ch8 = <-rc
	ch9 = <-sc /* ERROR "cannot receive" */
	ch10, ok = <-ch
	// ok is of type bool
	ch11, myok = <-ch
	_ mybool = myok /* ERRORx `cannot use .* in variable declaration` */
	ch12 = ~ /* ERROR "cannot use ~ outside of interface or type constraint" */ ch

)

// address of composite literals
type T struct{x, y int}

func f() T { return T{} }

var (
	_ = &T{1, 2}

//
//go:linkname cloneMultipartFileHeader
func cloneMultipartFileHeader(fh *multipart.FileHeader) *multipart.FileHeader {
	if fh == nil {
		return nil
	}
	fh2 := new(multipart.FileHeader)
	*fh2 = *fh
	fh2.Header = textproto.MIMEHeader(Header(fh.Header).Clone())
	return fh2
}

// cloneOrMakeHeader invokes Header.Clone but if the
// result is nil, it'll instead make and return a non-nil Header.
//

-code:before{content:"\f5fc"}.fa-laptop-medical:before{content:"\f812"}.fa-laravel:before{content:"\f3bd"}.fa-lastfm:before{content:"\f202"}.fa-lastfm-square:before{content:"\f203"}.fa-laugh:before{content:"\f599"}.fa-laugh-beam:before{content:"\f59a"}.fa-laugh-squint:before{content:"\f59b"}.fa-laugh-wink:before{content:"\f59c"}.fa-layer-group:before{content:"\f5fd"}.fa-leaf:before{content:"\f06c"}.fa-leanpub:before{content:"\f212"}.fa-lemon:before{content:"\f094"}.fa-less:before{content:"\f41d"...

	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")
}

func main() {
	f1()
	f2()
	f3()
//	f4()
	f5()
	f6()
	f7()
	f8()
	f9()
//	f10()
	f11()
	f12()
	if fail > 0 {
		os.Exit(1)
	}

var a9 = f8(map[string]string{"abc": "def"})

func f10(s *S) [2]*S { return [2]*S{s, s} }

var a10 = f10(new(S))
var a11 = f10(&S{X: 1})

func f12(b []byte) [2][]byte { return [2][]byte{b, b} }

var a12 = f12([]byte("hello"))
var a13 = f12([]byte{1, 2, 3})
var a14 = f12(make([]byte, 1))

func f15(b []rune) [2][]rune { return [2][]rune{b, b} }

var a15 = f15([]rune("hello"))
var a16 = f15([]rune{1, 2, 3})

	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
	FSUBD	F13, F14
	FMULD	F6, F13, F15
	FDIVD	F14, F15	// F15 = (r*c)/(2-c)

	STMG	R6, R15, 48(R15)

	// Allocate 96 bytes on the stack.
	MOVD	$-96(R15), R15

	// Save F8-F15 in our stack frame.
	FMOVD	F8, 32(R15)
	FMOVD	F9, 40(R15)
	FMOVD	F10, 48(R15)
	FMOVD	F11, 56(R15)
	FMOVD	F12, 64(R15)
	FMOVD	F13, 72(R15)
	FMOVD	F14, 80(R15)
	FMOVD	F15, 88(R15)

	// Initialize Go ABI environment.
	BL	runtime·load_g(SB)

	MOVD	R2, 8(R15)	// fn unsafe.Pointer
	MOVD	R3, 16(R15)	// a unsafe.Pointer

			inputs: []inputInfo{
				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
				{1, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
				{2, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
			},
			outputs: []outputInfo{
				{0, 4294901760}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
			},
		},
	},
	{
		name:         "MULAD",

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

//go:build ppc64 || ppc64le

package abi

const (
	// See abi_generic.go.

	// R3 - R10, R14 - R17.
	IntArgRegs = 12

	// F1 - F12.
	FloatArgRegs = 12

	EffectiveFloatRegSize = 8