package p

func New() resource {
	return &Client{}
}

type resource interface {
	table()
}

type Client struct {
	m map[Key1]int
}

func (c *Client) table() {}

type Key1 struct {
	K Key2
}

type Key2 struct {
	f [2]any

	m := make(map[string]bool)
	key1 := strings.Repeat("X", 1<<20)
	key2 := strings.Repeat("X", 1<<20) // equal but different instance
	m[key1] = true
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = m[key2]
	}
}

func BenchmarkMegEmptyMap(b *testing.B) {
	m := make(map[string]bool)
	key := strings.Repeat("X", 1<<20)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_, _ = m[key]
	}
}

  XlaSerializedCacheEntry entry;
  TF_ASSERT_OK(ReadTextOrBinaryProto(
      Env::Default(), GetFilePath(key1, persistor.persistent_cache_directory()),
      &entry));
  // Change the entry's key to key2.
  *entry.mutable_key() = key2;
  // Write the modified entry to file corresponding to key2.
  TF_ASSERT_OK(WriteBinaryProto(

// RUN: tf-tfrt-opt -tfrt-reorder-tf-assert %s | FileCheck %s

// CHECK-LABEL: @reorder_assert
func.func @reorder_assert(%key0: tensor<!tf_type.string>, %key1: tensor<!tf_type.string>) -> (tensor<i64>, tensor<i64>) {
  %error_message = "tf.Const"() {value = dense<"error"> : tensor<!tf_type.string>} : () -> tensor<!tf_type.string>
  %default = "tf.Const"() {value = dense<-1> : tensor<i64>} : () -> tensor<i64>

bqHKOPLhLn0UNbUmMzzrPo71y7qiMDmv5D8K/aVgxiX7roDSv9PSqwsZ3mw+EV4L
Qr12Aw2WG2uNijO99r02xqNU6vvHEglWH/f5gT4eYNEtGTqyp5PNTuYkI7GKybBg
EPtLjZykvvWJNn/P6KdmcsxQthX3XnbCIRq2LDL7A4GNor2DcqTyOw3cjy0=
=zmeZ
-----END PGP PUBLIC KEY BLOCK-----

-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: BCPG v1.68

mQINBFrDOW0BEAC9byiOScTIrOeZ4+nUJHx5nApGe1jT0RBK6QGl0utlqWubJS3W
oOt11vQPbugBTTX9QkIFRARxs/gqkToJR2UqfJJKE6FdtKStSsVGGesnYM+5Tp0v

	}
	m[v]++
}

type key2[T1, T2 comparable] struct {
	f1 T1
	f2 T2
}

type Metric2[T1, T2 cmp2] struct {
	mu sync.Mutex
	m  map[key2[T1, T2]]int
}

func (m *Metric2[T1, T2]) Add(v1 T1, v2 T2) {
	m.mu.Lock()
	defer m.mu.Unlock()
	if m.m == nil {
		m.m = make(map[key2[T1, T2]]int)
	}
	m[key[T1, T2]{v1, v2}]++
}

type key3[T1, T2, T3 comparable] struct {
	f1 T1
	f2 T2

    public void test_register() {
        RenderData data = new RenderData();

        RenderDataUtil.register(data, "key1", null);
        assertNull(data.getDataMap().get("key1"));

        RenderDataUtil.register(data, "key5", "");
        assertEquals(data.getDataMap().get("key5"), "");

    }

		},
		{
			name: "@request.auth.claims.key1-key2",
			in:   &networking.StringMatch{MatchType: &networking.StringMatch_Exact{Exact: "exact"}},
			want: authz.MetadataMatcherForJWTClaims([]string{"key1-key2"}, authzmatcher.StringMatcher("exact"), false),
		},
		{
			name: "@request.auth.claims.prefix",

        key8[ 4 ] = (byte) ( ( key[ 3 ] << 4 ) | ( ( key[ 4 ] & 0xFF ) >>> 4 ) );
        key8[ 5 ] = (byte) ( ( key[ 4 ] << 3 ) | ( ( key[ 5 ] & 0xFF ) >>> 5 ) );
        key8[ 6 ] = (byte) ( ( key[ 5 ] << 2 ) | ( ( key[ 6 ] & 0xFF ) >>> 6 ) );
        key8[ 7 ] = (byte) ( key[ 6 ] << 1 );
        for ( int i = 0; i < key8.length; i++ ) {
            key8[ i ] ^= Integer.bitCount(key8[ i ] ^ 1) & 1;

	}{
		"can decrypt using the correct key": {
			encryptKey:       key1,
			decryptKey:       key1,
			data:             testData,
			expectDecryptErr: false,
		},
		"can't decrypt using incorrect key": {
			encryptKey:       key1,
			decryptKey:       key2,
			data:             testData,
			expectDecryptErr: true,
		},
		"can't decrypt without a key": {
			encryptKey:       key1,
			decryptKey:       []byte{},