var x int
	_ = x
	var ch = make(chan bool, 1)

	f1 := func() {
		x = 1
		ch <- true
	}
	f2 := func() { go f1() }
	f3 := func() { go f2() }
	f4 := func() { go f3() }

	go f4()
	x = 2
	<-ch
}

// A nil pointer in a mutex method call should not
// corrupt the race detector state.
// Used to hang indefinitely.
func TestNoRaceNilMutexCrash(t *testing.T) {

00000180  08 0b 90 be c8 dc df 7d  6e e7 85 c9 ab dd be a9  |.......}n.......|
00000190  57 c4 6a 76 36 bb a8 4b  e2 be d1 28 67 3b a9 0c  |W.jv6..K...(g;..|
000001a0  a1 78 2e e4 af f4 51 a3  f5 8c b3 8d c8 7c 8e e7  |.x....Q......|..|
000001b0  d2 7f 38 91 04 42 f4 e9  ae e2 3a 3d 37 10 78 f3  |..8..B....:=7.x.|
000001c0  2d 9c 9f f7 4f 49 f0 45  bd 1e 8d 7d e3 84 b9 9a  |-...OI.E...}....|

000000d0  58 95 86 e9 3d 19 e6 5c  27 73 60 c8 8d 78 02 f4  |X...=..\'s`..x..|
000000e0  1d a4 98 09 a3 19 70 69  3c 25 62 66 2a ab 22 23  |......pi<%bf*."#|
000000f0  c5 7b 85 38 4f 2e 09 73  32 a7 bd 3e 9b ad ca 84  |.{.8O..s2..>....|
00000100  07 e6 0f 3a ff 77 c5 9d  41 85 00 8a b6 9b ee b0  |...:.w..A.......|
00000110  a4 3f 2d 4c 4c e6 42 3e  bb 51 c8 dd 48 54 f4 0c  |.?-LL.B>.Q..HT..|

00000080  ee 16 00 00 04 03 00 46  30 44 02 20 1c 4b 82 5d  |.......F0D. .K.]|
00000090  95 6e 67 5b db 04 95 4b  f6 ce f4 32 3e 86 7a 7a  |.ng[...K...2>.zz|
000000a0  32 ab 18 60 74 de 08 da  05 91 4c 2f 02 20 73 54  |2..`t.....L/. sT|
000000b0  1b 6e 7f a1 b0 7d 11 bc  e6 f3 85 2f 97 66 1a f7  |.n...}...../.f..|
000000c0  8a e4 10 25 8f 12 f4 6f  39 0f d2 9e 18 f0 00 76  |...%...o9......v|

package main

import (
	"encoding/json"
)

type A[T any] struct {
	F1 string `json:"t1"`
	F2 T      `json:"t2"`
	B  B      `json:"t3"`
}

type B struct {
	F4 int `json:"t4"`
}

func a[T any]() {
	data := `{"t1":"1","t2":2,"t3":{"t4":4}}`
	a1 := A[T]{}
	if err := json.Unmarshal([]byte(data), &a1); err != nil {
		panic(err)
	}

func F2(t *T2) {
	t[1<<31+1] = 42
}

type T3 [1<<15 + 1][1<<15 + 1]int

func F3(t *T3) {
	t[1<<15][1<<15] = 42
}

type S struct {
	A int32
	B int32
}

type T4 [1<<29 + 1]S

func F4(t *T4) {
	t[1<<29].B = 42

00000100  35 3d 8e 8a 03 ca ed 32  a9 16 bb 71 88 d5 5f a1  |5=.....2...q.._.|
00000110  1b ec ee 9e 3d 8c f4 d0  c2 5b 72 84 3c 75 aa de  |....=....[r.<u..|
00000120  10 a7 78 5a 62 3e b9 11  da 83 94 29 d3 40 8f da  |..xZb>.....).@..|
00000130  3c f4 32 90 c0 25 b7 f0  fc 6b 16 c1 ab 80 69 79  |<.2..%...k....iy|
00000140  5e dd 95 5a ba e4 5a 68  64 a6 44 f5 a2 3a d6 30  |^..Z..Zhd.D..:.0|

// Use the functions in one.go so that the inlined
// forms get type-checked.

package pkg2

import "./one"

func use() {
	one.F1(nil)
	one.F2(nil)
	one.F3()
	one.F4(1)

	var t *one.T
	t.M()
	t.MM()
}

var V = []one.PB{{}, {}}

func main() {}

func typ(x interface{}) reflect.Type { return reflect.ValueOf(x).Type() }

var x = reflect.New(reflect.StructOf([]reflect.StructField{
	{Name: "F5", Type: reflect.StructOf([]reflect.StructField{
		{Name: "F4", Type: reflect.ArrayOf(5462,
			reflect.SliceOf(typ(uint64(0))))},
	})},

// (test cases for issues #5217, #25790 and variants)
func f1(x f1 /* ERROR "not a type" */ ) {}
func f2(x *f2 /* ERROR "not a type" */ ) {}
func f3() (x f3 /* ERROR "not a type" */ ) { return }
func f4() (x *f4 /* ERROR "not a type" */ ) { return }
// TODO(#43215) this should be detected as a cycle error
func f5([unsafe.Sizeof(f5)]int) {}

func (S0) m1 (x S0.m1 /* ERROR "S0.m1 is not a type" */ ) {}