// >= 16 bytes to avoid tiny alloc.
	a, b int
}

func main() {
	debug.SetGCPercent(1)
	for i := 0; i < 100000; i++ {
		m := make(map[*T]struct{}, 0)
		for j := 0; j < 20; j++ {
			// During the call to mapassign_fast64, the key argument
			// was incorrectly treated as a uint64. If the stack was
			// scanned during that call, the only pointer to k was
			// missed, leading to *k being collected prematurely.
			k := new(T)

// See go.dev/issue/67401.
//
//go:linkname mapassign_fast64
func mapassign_fast64(t *maptype, h *hmap, key uint64) unsafe.Pointer {
	if h == nil {
		panic(plainError("assignment to entry in nil map"))
	}
	if raceenabled {
		callerpc := getcallerpc()
		racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapassign_fast64))
	}
	if h.flags&hashWriting != 0 {
		fatal("concurrent map writes")

	{"runtime.mapaccess2_fast32", 1},
	{"runtime.mapaccess2_fast64", 1},
	{"runtime.mapaccess2_faststr", 1},
	{"runtime.mapaccess2_fat", 1},
	{"runtime.mapassign", 1},
	{"runtime.mapassign_fast32", 1},
	{"runtime.mapassign_fast32ptr", 1},
	{"runtime.mapassign_fast64", 1},
	{"runtime.mapassign_fast64ptr", 1},
	{"runtime.mapassign_faststr", 1},
	{"runtime.mapiterinit", 1},
	{"runtime.mapdelete", 1},
	{"runtime.mapdelete_fast32", 1},

func mapassign(mapType *byte, hmap map[any]any, key *any) (val *any)
func mapassign_fast32(mapType *byte, hmap map[any]any, key uint32) (val *any)
func mapassign_fast32ptr(mapType *byte, hmap map[any]any, key unsafe.Pointer) (val *any)
func mapassign_fast64(mapType *byte, hmap map[any]any, key uint64) (val *any)
func mapassign_fast64ptr(mapType *byte, hmap map[any]any, key unsafe.Pointer) (val *any)

	{"mapaccess2_fast64", funcTag, 87},
	{"mapaccess2_faststr", funcTag, 88},
	{"mapaccess2_fat", funcTag, 89},
	{"mapassign", funcTag, 80},
	{"mapassign_fast32", funcTag, 81},
	{"mapassign_fast32ptr", funcTag, 90},
	{"mapassign_fast64", funcTag, 82},
	{"mapassign_fast64ptr", funcTag, 90},
	{"mapassign_faststr", funcTag, 83},
	{"mapiterinit", funcTag, 91},
	{"mapdelete", funcTag, 91},

// See go.dev/issue/67401.
//
//go:linkname mapassign_fast32
func mapassign_fast32(t *maptype, h *hmap, key uint32) unsafe.Pointer {
	if h == nil {
		panic(plainError("assignment to entry in nil map"))
	}
	if raceenabled {
		callerpc := getcallerpc()
		racewritepc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapassign_fast32))
	}
	if h.flags&hashWriting != 0 {
		fatal("concurrent map writes")