func F() {
	v := _S[I]{}
	if v.x != nil {
		panic(v)
	}
}

// Testing the various combinations of method expressions.
type S1 struct{}

func (*S1) M() {}

type S2 struct{}

func (S2) M() {}

func _F1[T interface{ M() }](t T) {
	_ = T.M
}

func F2() {
	_F1(&S1{})
	_F1(S2{})
	_F1(&S2{})
}

func main() {
	F()
	F2()

		{true, T3{i: b, s: "foo"}, T3{i: b, s: "bar"}},
		{false, T3{s: "foo", j: b}, T3{s: "bar", j: b}},
		{true, T3{i: b, s: "fooz"}, T3{i: b, s: "bar"}},
		{false, T3{s: "fooz", j: b}, T3{s: "bar", j: b}},
		{true, A{s1, s2}, A{s2, s1}},
		{true, s1, s2},
		{false, S4{[1000]byte{0}, func() {}}, S4{[1000]byte{1}, func() {}}},
	} {
		f := func() {
			defer func() {
				if recover() != nil {

func pstring(s *string) {
	println(*s)
}

func main() {
	all := []*string{
		&S1, &S2, &S3, &S4, &S5, &S6, &S7, &S8, &S9, &S10,
		&p.S1, &p.S2, &p.S3, &p.S4, &p.S5, &p.S6, &p.S7, &p.S8, &p.S9, &p.S10,
	}
	for _, ps := range all {
		pstring(ps)
	}
}

var S1 string
var S2 string
var S3 string
var S4 string
var S5 string
var S6 string
var S7 string
var S8 string

}

func TestReadFilePath(t *testing.T) {
	fsys := os.DirFS(t.TempDir())
	_, err1 := ReadFile(fsys, "non-existent")
	_, err2 := ReadFile(struct{ FS }{fsys}, "non-existent")
	if s1, s2 := errorPath(err1), errorPath(err2); s1 != s2 {
		t.Fatalf("s1: %s != s2: %s", s1, s2)
	}

		~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
		~float32 | ~float64 |
		~complex64 | ~complex128
}

func DotProduct[T Numeric](s1, s2 []T) T {
	if len(s1) != len(s2) {
		panic("DotProduct: slices of unequal length")
	}
	var r T
	for i := range s1 {
		r += s1[i] * s2[i]
	}
	return r
}

// NumericAbs matches numeric types with an Abs method.
type NumericAbs[T any] interface {
	Numeric

// Issue 8620. Used to fail with -race.

package main

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func test(s1, s2 []struct{}) {
	n := min(len(s1), len(s2))
	if copy(s1, s2) != n {
		panic("bad copy result")
	}
}

func main() {
	var b [100]struct{}
	test(b[:], b[:])
	test(b[1:], b[:])
	test(b[:], b[2:])

// run

// Copyright 2009 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 main

func main() {
	s1 := "hi";
	s2 := "ho";
	s1 += s2;

        expect:
        def s1 = updateDir(single, dir2)
        assertDirectorySnapshot(s1, dir1)
        assertDirectorySnapshot(s1, child)
        assertDirectorySnapshot(s1, dir2)
        assertHasNoMetadata(s1, dir3)
        assertHasNoMetadata(s1, tooFew)
        assertHasNoMetadata(s1, tooMany)
        assertPartialDirectoryNode(s1, parent)
        flatten(s1) == [parent.path, "1:dir1", "2:child1", "1:dir2"]

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package one

type I1 interface {
	f()
}

type S1 struct {
}

func (s S1) f() {
}

func F1(i1 I1) {

	;                                     \
	XORL     y1, y0;                      \ // y0 = (e>>25) ^ (e>>11)					// S1
	XORL     g, y2;                       \ // y2 = f^g	// CH
	VPADDD   XDWORD0, XTMP0, XTMP0;       \ // XTMP0 = W[-7] + W[-16]	// y1 = (e >> 6)	// S1
	RORXL    $6, e, y1;                   \ // y1 = (e >> 6)						// S1
	;                                     \