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

package main

import "runtime"

type T [10]int

var m map[*T]int

//go:noinline
func F() {
	m = map[*T]int{
		K(): V(), // the key temp should be live across call to V
	}
}

//go:noinline
func V() int { runtime.GC(); runtime.GC(); runtime.GC(); return 123 }

//go:noinline

Shinsuke Sugaya <******@****.***> 1553287182 +0900

// Source: ../../cmd/compile/internal/types2/map.go

// Copyright 2011 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 types

// A Map represents a map type.
type Map struct {
	key, elem Type
}

// NewMap returns a new map for the given key and element types.
func NewMap(key, elem Type) *Map {
	return &Map{key: key, elem: elem}
}

package config

import (
	"fmt"

	"istio.io/istio/pkg/test/scopes"
)

type Map map[string]any

func (m Map) Map(key string) Map {
	nested, ok := m[key]
	if !ok {
		return nil
	}
	out, ok := nested.(Map)
	if !ok {
		return nil
	}
	return out
}

func (m Map) String(key string) string {
	v, ok := m[key]
	if !ok || v == nil {
		return ""
	}
	str, ok := v.(string)

}

func concurrentMapWrites() {
	m := map[int]int{}
	c := make(chan struct{})
	go func() {
		for i := 0; i < 10000; i++ {
			m[5] = 0
			runtime.Gosched()
		}
		c <- struct{}{}
	}()
	go func() {
		for i := 0; i < 10000; i++ {
			m[6] = 0
			runtime.Gosched()
		}
		c <- struct{}{}
	}()
	<-c
	<-c
}

func concurrentMapReadWrite() {
	m := map[int]int{}
	c := make(chan struct{})

	val         V
	left, right *node[K, V]
}

// New returns a new map.
func New[K, V any](compare func(K, K) int) *Map[K, V] {
        return &Map[K, V]{compare: compare}
}

// find looks up key in the map, and returns either a pointer
// to the node holding key, or a pointer to the location where
// such a node would go.
func (m *Map[K, V]) find(key K) **node[K, V] {
	pn := &m.root
	for *pn != nil {

package orderedmap

import "chans"

// Map is an ordered map.
type Map[K, V any] struct {
	root    *node[K, V]
	compare func(K, K) int
}

// node is the type of a node in the binary tree.
type node[K, V any] struct {
	key         K
	val         V
	left, right *node[K, V]
}

// New returns a new map.
func New[K, V any](compare func(K, K) int) *Map[K, V] {

// Copyright 2023 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 abi

// Map constants common to several packages
// runtime/runtime-gdb.py:MapTypePrinter contains its own copy
const (
	// Maximum number of key/elem pairs a bucket can hold.
	MapBucketCountBits = 3 // log2 of number of elements in a bucket.
	MapBucketCount     = 1 << MapBucketCountBits

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

package main

import (
	"fmt"
	"reflect"
	"strconv"
)

// Map calls the function f on every element of the slice s,
// returning a new slice of the results.
func mapper[F, T any](s []F, f func(F) T) []T {
	r := make([]T, len(s))
	for i, v := range s {
		r[i] = f(v)
	}
	return r

import (
	"reflect"

	"istio.io/istio/pkg/ptr"
)

// TypeMap provides a map that holds a map of Type -> Value. There can be only a single value per type.
// The value stored for a type must be of the same type as the key.
type TypeMap struct {
	inner map[reflect.Type]any
}

func NewTypeMap() TypeMap {
	return TypeMap{make(map[reflect.Type]any)}
}

func Set[T any](t TypeMap, v T) {