public static <K, V> ImmutableBiMap<K, V> of(K k1, V v1, K k2, V v2) {
    return new RegularImmutableBiMap<K, V>(ImmutableMap.of(k1, v1, k2, v2));
  }

  public static <K, V> ImmutableBiMap<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
    return new RegularImmutableBiMap<K, V>(ImmutableMap.of(k1, v1, k2, v2, k3, v3));
  }

  public static <K, V> ImmutableBiMap<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {

        assertCanConsumeK2BuildLogic()
    }

    @Test
    @Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    fun `can try k2 with included build for build logic using kotlin-dsl plugin`() {

        // This test doesn't use a .gradle.kts precompiled script because K2 doesn't support scripts yet

        withDefaultSettingsIn("build-logic")
        withBuildScriptIn("build-logic", """

                if (LANG_KEY.equals(k1)) {
                    return -1;
                }
                final String k2 = o2.getKey();
                if (LANG_KEY.equals(k2)) {
                    return -1;
                }
                return k1.compareTo(k2);
            });
            return new LinkedHashSet<>(list);
        }
        return parent.entrySet();
    }

fun test() {
    val string = <expr>(String)</expr>::class
}

// IGNORE_FE10

  l1: v1
  l2: v2
ns1/p2:
  l1: v1
  l2: v22
  l3: v3
ns1/p3:
  l1: v1
  l2: v2
  l3: v3
  l4: v4
`
	testClusterResourcesAnnotations = `
ns1/p1:
  k2: v2
ns1/p2:
  k1: v1
  k2: v2
  k3: v33
ns1/p3:
  k1: v1
  k2: v22
  k3: v3
ns1/p4:
  k1: v1
  k4: v4
`

	p1c1 = "ns1/d1/p1/c1"
	p1c2 = "ns1/d1/p1/c2"
	p2c3 = "ns1/d1/p2/c3"
	p3c4 = "ns1/d2/p3/c4"
	p3c5 = "ns1/d2/p3/c5"

                new DefaultMavenMetadataCache.CacheKey(a1, false, lr1, Collections.singletonList(rr1));
        DefaultMavenMetadataCache.CacheKey k2 =
                new DefaultMavenMetadataCache.CacheKey(a2, false, lr2, Collections.singletonList(rr2));

        assertEquals(k1.hashCode(), k2.hashCode());
    }

        get() = withValidityAssertion { descriptor.isSuspend }

    override val isOperator: Boolean
        get() = withValidityAssertion {
            if (descriptor.isDynamic()) {
                // For consistency with the K2 implementation, see `FirDynamicMembersStorage`
                return@withValidityAssertion true
            }
            descriptor.isOperator
        }

    override val isExternal: Boolean

//	url('https://example.com/path with spaces/').getEscapedPath() // returns '/path%20with%20spaces/'
//	url('https://example.com').getEscapedPath() // returns ''
//	url('https://example.com/path?k1=a&k2=b&k2=c').getQuery() // returns { 'k1': ['a'], 'k2': ['b', 'c']}
//	url('https://example.com/path?key with spaces=value with spaces').getQuery() // returns { 'key with spaces': ['value with spaces']}
//	url('https://example.com/path?').getQuery() // returns {}

				m[K{float64(i) + 1}] = V{}
			}
		}

		// Clone m, which should freeze the map's contents.
		c := Clone(m)

		// Update m with new key and value.
		k2, v2 := k1, v1
		k2[0] = negZero
		v2[0] = 1.0
		m[k2] = v2

		// Make sure c still has its old key and value.
		for k, v := range c {
			if math.Signbit(k[0]) {
				t.Errorf("tst%d: sign bit of key changed; got %v want %v", tst, k, k1)

        }
    }
    while (filesQueueToAnalyze.isNotEmpty()) {
        val file = filesQueueToAnalyze.removeFirst()
        analyze(file) {
            require(this is KaFe10Session) {
                "K2 implementation shouldn't call this code"
            }
            file.accept(InlineDelegatedPropertyAccessorsAnalyzer(analysisContext, collector))
        }
    }
}

@OptIn(KaAnalysisNonPublicApi::class)