{nil, "0  nil"},
	{true, "0  true"},
	{42, "0  42"},
	{3.14, "0  3.14"},
	{1 + 2.718i, "0  (1+2.718i)"},
	{"foobar", "0  \"foobar\""},

	// maps
	{map[Expr]string{}, `0  map[ast.Expr]string (len = 0) {}`},
	{map[string]int{"a": 1},
		`0  map[string]int (len = 1) {
		1  .  "a": 1
		2  }`},

	// pointers
	{new(int), "0  *0"},

	// arrays
	{[0]int{}, `0  [0]int {}`},
	{[3]int{1, 2, 3},

// > 0 if the first is greater.
func New[K, V any](compare func(K, K) int) *Map[K, V] {
	return &Map[K, V]{compare: compare}
}

// NewOrdered returns a new map whose key is an ordered type.
// This is like New, but does not require providing a compare function.
// The map compare function uses the obvious key ordering.
func NewOrdered[K Ordered, V any]() *Map[K, V] {
	return New[K, V](func(k1, k2 K) int {
		switch {
		case k1 < k2:

// license that can be found in the LICENSE file.

// Embedding of stand-alone type parameters is not permitted.

package p

type (
        _[P any] interface{ *P | []P | chan P | map[string]P }
        _[P any] interface{ P /* ERROR "term cannot be a type parameter" */ }
        _[P any] interface{ ~P /* ERROR "type in term ~P cannot be a type parameter" */ }

type _ interface {
	int
	[]byte
	[10]int
	struct{}
	*int
	func()
	interface{}
	map[string]int
	chan T
	chan<- T
	<-chan T
	T[int]
}

type _ interface {
	int | string
	[]byte | string
	[10]int | string
	struct{} | string
	*int | string
	func() | string
	interface{} | string
	map[string]int | string
	chan T | string
	chan<- T | string
	<-chan T | string
	T[int] | string
}

// delete

type M0 interface{ int }
type M1 interface{ map[string]int }
type M2 interface { map[string]int | map[string]float64 }
type M3 interface{ map[string]int | map[rune]int }
type M4[K comparable, V any] interface{ map[K]V | map[rune]V }

func _[T any](m T) {
	delete(m /* ERROR "not a map" */, "foo")
}

func _[T M0](m T) {
	delete(m /* ERROR "not a map" */, "foo")
}

func _[T M1](m T) {

		i0 /* ERROR "invalid recursive type: i0 refers to itself" */ interface{ i0 }

		// maps
		m0 map[m0 /* ERROR "invalid map key" */ ]m0

		// channels
		c0 chan c0
	)
}

// test cases for issue 6667

type A [10]map[A /* ERROR "invalid map key" */ ]bool

type S struct {
	m map[S /* ERROR "invalid map key" */ ]bool
}

// test cases for issue 7236

package main

type T struct {
	m map[int]int
}

func main() {
	t := T{
		m: make(map[int]int),
	}
	t.Inc(5)
	t.Inc(7)
}

func (s *T) Inc(key int) {
	v := s.m[key] // break, line 16
	v++
	s.m[key] = v // also here

)

// importMap computes the import map for a package by traversing the
// entire exported API each of its imports.
//
// This is a workaround for the fact that we cannot access the map used
// internally by the types.Importer returned by go/importer. The entries
// in this map are the packages and objects that may be relevant to the
// current analysis unit.
//
// Packages in the map that are only indirectly imported may be

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

// Issue 52846: gofrontend crashed with alias as map key type

package p

type S struct {
	F string
}

type A = S

}

func parseVectorSetup(vector string) map[string]string {
	vals := map[string]string{}
	for _, l := range strings.Split(vector, "\n") {
		fields := strings.Split(l, ": ")
		vals[fields[0]] = fields[1]
	}
	return vals
}

func parseVectorEncryptions(vector string) []map[string]string {
	vals := []map[string]string{}
	for _, section := range strings.Split(vector, "\n\n") {
		e := map[string]string{}