return false
	}
	b0 := b[0]
	if b0 < hangulBase0 {
		return false
	}
	b1 := b[1]
	switch {
	case b0 == hangulBase0:
		return b1 >= hangulBase1
	case b0 < hangulEnd0:
		return true
	case b0 > hangulEnd0:
		return false
	case b1 < hangulEnd1:
		return true
	}
	return b1 == hangulEnd1 && b[2] < hangulEnd2
}

func isHangulString(b string) bool {

00000000  14 03 03 00 01 01 16 03  03 00 40 9e 65 27 5b 92  |..........@.e'[.|
00000010  1e 2b 1a bc 81 ab 85 29  51 c1 38 04 b6 97 e5 4b  |.+.....)Q.8....K|
00000020  b1 7d a5 e2 6d e7 b1 1a  33 6c f1 3d a4 9c de 2d  |.}..m...3l.=...-|
00000030  b3 8a 01 da cc f1 d7 83  b1 1e 84 cb b7 e7 fe e6  |................|
00000040  26 83 b0 2d 6f a9 77 46  55 44 7a                 |&..-o.wFUDz|
>>> Flow 5 (client to server)

	if got, want := i1.Largest(), 3; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	b3 := &a.List[byte]{nil, byte(1)}
	b2 := &a.List[byte]{b3, byte(3)}
	b1 := &a.List[byte]{b2, byte(2)}
	if got, want := b1.Largest(), byte(3); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	f3 := &a.List[float64]{nil, 13.5}
	f2 := &a.List[float64]{f3, 1.2}
	f1 := &a.List[float64]{f2, 4.5}

go 1.17

require example.com/b v0.1.0
-- a/a.go --
package a
-- a/a_test.go --
package a_test

import _ "example.com/b"

-- b1/go.mod --
module example.com/b

go 1.17

require example.com/c v0.1.0
-- b1/b.go --
package b
-- b1/b_test.go --
package b_test
import _ "example.com/c"

-- b2/go.mod --
module example.com/b

go 1.17

require example.com/c v0.1.0

	b0.Event("GoStatus", trace.GoID(1), trace.ThreadID(0), go122.GoRunning)
	b0.Event("GoSyscallBegin", testgen.Seq(1), testgen.NoStack)
	b0.Event("GoSyscallEndBlocked")

	// A bare M steals the goroutine's P.
	b1 := g.Batch(trace.ThreadID(1), 0)
	b1.Event("ProcSteal", trace.ProcID(0), testgen.Seq(2), trace.ThreadID(0))

func (t *T2) _() {}

// Already reported about the invalid blank interface method above;
// no need to report about not implementing it.
var b1 B1 = &T2{}

}

type UnpairedVersion interface {
	Version
}

var _ Constraint = UnpairedVersion(nil)


// derived test case from issue #21804

type (
	_ interface{ m(B1) }
	A1 interface{ a(D1) }
	B1 interface{ A1 }
	C1 interface{ B1 }
	D1 interface{ C1 }
)

var _ A1 = C1(nil)


// derived test case from issue #22701

func F(x I4) interface{} {
	return x.Method()
}

//go:noinline
//go:registerparams
func F() (a int, b string, _ int, c S, d [2]int) {
	a, b, c, d = a0, b0, c0, d0
	defer func() { recover() }()
	panic("XXX")
	return
}

func main() {
	a1, b1, zero, c1, d1 := F()
	if a1 != a0 || b1 != b0 || c1 != c0 || d1 != d0 || zero != 0 { // unnamed result gets zero value
		panic("FAIL")
	}

)

replace (
	example.net/a v0.1.0 => ./a1
	example.net/a v0.2.0 => ./a2
	example.net/b v0.1.0 => ./b1
	example.net/b v0.2.0 => ./b2
	example.net/c v0.1.0 => ./c1
)
-- a1/go.mod --
module example.net/a

go 1.19
-- a2/go.mod --
module example.net/a

go 1.19

require example.net/b v0.2.0
-- b1/go.mod --
module example.net/b

go 1.19
-- b2/go.mod --
module example.net/b

go 1.19

type T struct {
	f *[unsafe.Sizeof(T /* ERROR "invalid recursive type" */ {})]int
}

// a mutually recursive case using unsafe.Sizeof
type (
	A1 struct {
		_ [unsafe.Sizeof(B1{})]int
	}

	B1 struct {
		_ [unsafe.Sizeof(A1 /* ERROR "invalid recursive type" */ {})]int
	}
)

// a mutually recursive case using len
type (
	A2 struct {
		f [len(B2{}.f)]int
	}

	B2 struct {