// map[four:4 two:2]
}

func ExampleEqual() {
	m1 := map[int]string{
		1:    "one",
		10:   "Ten",
		1000: "THOUSAND",
	}
	m2 := map[int]string{
		1:    "one",
		10:   "Ten",
		1000: "THOUSAND",
	}
	m3 := map[int]string{
		1:    "one",
		10:   "ten",
		1000: "thousand",
	}

	fmt.Println(maps.Equal(m1, m2))
	fmt.Println(maps.Equal(m1, m3))
	// Output:
	// true
	// false
}

	s := initStore(b)
	gvk := config.GroupVersionKind{
		Group:   "networking.istio.io",
		Version: "v1alpha3",
		Kind:    "ServiceEntry",
	}
	b.ResetTimer()
	for n := 0; n < b.N; n++ {
		// get one thousand times
		for i := 0; i < 1000; i++ {
			if s.Get(gvk, strconv.Itoa(i), "ns") == nil {
				b.Fatal("get failed")
			}
		}
	}
}

func BenchmarkStoreList(b *testing.B) {
	s := initStore(b)

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

// Test -run flag

//go:generate echo oh yes my man
//go:generate echo no, no, a thousand times no

package p
-- generate/env_test.go --
package main_test

//go:generate echo $GOPACKAGE
-- generate/env_pwd.go --
package p

// CHECK:           %[[GRAPH:.*]]:2 = tf_executor.graph {
// CHECK:             %[[THOUSAND:.*]], %{{.*}} = tf_executor.island wraps "tf.Const"() <{value = dense<1000> : tensor<i32>}> : () -> tensor<i32>
// CHECK:             %[[STACK_HANDLE:.*]], %{{.*}} = tf_executor.island wraps "tf.StackV2"(%[[THOUSAND]]) <{elem_type = f32}> : (tensor<i32>) -> tensor<!tf_type.resource<tensor<f32>>>

	// this allows the cache to grow to an infinite size for up to a day.
	// there is unlikely to be any meaningful memory impact on the server
	// because the cache will likely never have more than a few thousand entries.
	// each entry can be large due to an internal cache that maps the DEK seed to individual
	// DEK entries, but that cache has an aggressive TTL to keep the size under control.

217F          ; mapped                 ; 006D          # 1.1  SMALL ROMAN NUMERAL ONE THOUSAND
2180..2182    ; valid                  ;      ; NV8    # 1.1  ROMAN NUMERAL ONE THOUSAND C D..ROMAN NUMERAL TEN THOUSAND
2183          ; disallowed                             # 3.0  ROMAN NUMERAL REVERSED ONE HUNDRED

Forking compilation rarely impacts the performance of small projects.
But you should consider it if a single task compiles more than a thousand source files together.

==== Switch internal-only dependencies to implementation visibility

NOTE: Only libraries can define `api` dependencies. Use the