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 }

	S4 /* ERROR "invalid recursive type" */ struct{ S5 }
	S5 struct{ S6 }
	S6 S4

	// pointers
	P0 *P0

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

package p

func f[_ comparable]() {}

type S1 struct{ x int }
type S2 struct{ x any }
type S3 struct{ x [10]interface{ m() } }

func _[P1 comparable, P2 S2]() {
	_ = f[S1]
	_ = f[S2]
	_ = f[S3]

	type L1 struct { x P1 }
	type L2 struct { x P2 }
	_ = f[L1]
	_ = f[L2 /* ERROR "L2 does not satisfy comparable" */ ]
}

// compile

// Copyright 2024 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 p

type (
	s  = struct{ f func(s1) }
	s1 = struct{ i I }
)

type I interface {
	S() *s

// A simplified version of the code in the original report.
type S[T any] struct{}
var V = S[any]{}
func (fs *S[T]) M(V.M /* ERROR "V.M is not a type" */) {}

// Other minimal reproducers.
type S1[T any] V1.M /* ERROR "V1.M is not a type" */
type V1 = S1[any]

type S2[T any] struct{}
type V2 = S2[any]
func (fs *S2[T]) M(x V2.M /* ERROR "V2.M is not a type" */ ) {}

// The following still panics, as the selector is reached from check.expr

}

func _[P map[int]int]() {
	type A = P
	var m A
	clear(m) // don't report an error for m
}

type S1 struct {
	x int "S1.x"
}

type S2 struct {
	x int "S2.x"
}

func _[P1 S1, P2 S2]() {
	type A = P1
	var p A
	_ = P2(p) // conversion must be valid
}

func _[P1 S1, P2 S2]() {
	var p P1
	type A = P2
	_ = A(p) // conversion must be valid
}

func _[P int | string]() {

func CloneBad[M ~map[K]V, K comparable, V any](m M) M {
	r := make(M, len(m))
	for k, v := range m {
		r[k] = v
	}
	return r
}

func main() {
	s1 := &S{"one"}
	s2 := &S{"two"}

	m := CloningMap[string, I]{inner: make(map[string]I)}
	m = m.With("a", s1)
	m = m.With("b", s2)

	it, found := m.inner["a"]
	if !found {
		panic("a not found")
	}
	if _, ok := it.(*S); !ok {

/** Tests for {@link MoreObjects}. */
@GwtCompatible(emulated = true)
public class MoreObjectsTest extends TestCase {
  public void testFirstNonNull_withNonNull() {
    String s1 = "foo";
    String s2 = MoreObjects.firstNonNull(s1, "bar");
    assertSame(s1, s2);

    Long n1 = 42L;
    Long n2 = MoreObjects.firstNonNull(null, n1);
    assertSame(n1, n2);

    Boolean b1 = true;

	v := *(*byte)(unsafe.Pointer(addr))
	t.Logf("addr %#x: %#x\n", addr, v)
}

func eqstring_generic(s1, s2 string) bool {
	if len(s1) != len(s2) {
		return false
	}
	// optimization in assembly versions:
	// if s1.str == s2.str { return true }
	for i := 0; i < len(s1); i++ {
		if s1[i] != s2[i] {
			return false
		}
	}
	return true
}

func TestEqString(t *testing.T) {

		h.Add(h, curve.P)
	}
	i := new(big.Int).Lsh(h, 1)
	i.Mul(i, i)
	j := new(big.Int).Mul(h, i)

	s1 := new(big.Int).Mul(y1, z2)
	s1.Mul(s1, z2z2)
	s1.Mod(s1, curve.P)
	s2 := new(big.Int).Mul(y2, z1)
	s2.Mul(s2, z1z1)
	s2.Mod(s2, curve.P)
	r := new(big.Int).Sub(s2, s1)
	if r.Sign() == -1 {
		r.Add(r, curve.P)
	}
	yEqual := r.Sign() == 0
	if xEqual && yEqual {

// disagree, or <0 if the lengths are the same and all elements
// are identical.
func compareUint32Slices(s1, s2 []uint32) int {
	if len(s1) != len(s2) {
		if len(s1) > len(s2) {
			return len(s2) + 1
		}
		return len(s1) + 1
	}
	for i := range s1 {
		if s1[i] != s2[i] {
			return i
		}
	}
	return -1
}

// compareFloat32Slices returns the first index where the two slices