VPOPCNTW X25, K3, X23                              // 6282fd0b54f9
	VPOPCNTW (CX), K3, X23                             // 62e2fd0b5439
	VPOPCNTW 99(R15), K3, X23                          // 62c2fd0b54bf63000000
	VPOPCNTW X20, K3, X2                               // 62b2fd0b54d4
	VPOPCNTW X5, K3, X2                                // 62f2fd0b54d5
	VPOPCNTW X25, K3, X2                               // 6292fd0b54d1

	VPCONFLICTD Y20, K3, Y7                            // 62b27d2bc4fc
	VPCONFLICTD -7(CX), K3, Y7                         // 62f27d2bc4b9f9ffffff
	VPCONFLICTD 15(DX)(BX*4), K3, Y7                   // 62f27d2bc4bc9a0f000000
	VPCONFLICTD Y14, K3, Y21                           // 62c27d2bc4ee
	VPCONFLICTD Y8, K3, Y21                            // 62c27d2bc4e8

  }

  /** Implementation of Hash128to64 from util/hash/hash128to64.h */
  @VisibleForTesting
  static long hash128to64(long high, long low) {
    long a = (low ^ high) * K3;
    a ^= (a >>> 47);
    long b = (high ^ a) * K3;
    b ^= (b >>> 47);
    b *= K3;
    return b;
  }

  /**
   * Computes intermediate hash of 32 bytes of byte array from the given offset. Results are

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutIfAbsent_supportedAbsent() {
    assertNull(
        "putIfAbsent(notPresent, value) should return null", getMap().putIfAbsent(k3(), v3()));
    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_supportedPresent() {
    assertEquals(

	VANDNPS 7(SI), Z19, K3, Z3                         // 62f16443559e07000000
	VANDNPS Z12, Z9, K3, Z30                           // 6241344b55f4
	VANDNPS Z22, Z9, K3, Z30                           // 6221344b55f6
	VANDNPS (AX), Z9, K3, Z30                          // 6261344b5530
	VANDNPS 7(SI), Z9, K3, Z30                         // 6261344b55b607000000

  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_otherMapWithDifferentEntries() {
    Map<K, V> other = newHashMap(getSampleEntries(getNumEntries() - 1));
    other.put(k3(), v3());
    assertFalse(
        "A Map should not equal another Map containing different entries.", getMap().equals(other));
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)

    assertEquals(
        "getOrDefault(absent, def) should return the default value",
        v3(),
        getMap().getOrDefault(k3(), v3()));
  }

  public void testGetOrDefault_absentNullDefault() {
    assertNull("getOrDefault(absent, null) should return null", getMap().getOrDefault(k3(), null));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testGetOrDefault_absentNull() {
    assertEquals(

	VPOPCNTD Z2, K3, Z22                               // 62e27d4b55f2
	VPOPCNTD Z31, K3, Z22                              // 62827d4b55f7
	VPOPCNTD 7(SI)(DI*4), K3, Z22                      // 62e27d4b55b4be07000000
	VPOPCNTD -7(DI)(R8*2), K3, Z22                     // 62a27d4b55b447f9ffffff
	VPOPCNTD Z2, K3, Z7                                // 62f27d4b55fa
	VPOPCNTD Z31, K3, Z7                               // 62927d4b55ff

    assertTrue("containsKey(present) should return true", getMap().containsKey(k0()));
  }

  public void testContains_no() {
    assertFalse("containsKey(notPresent) should return false", getMap().containsKey(k3()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testContains_nullNotContainedButAllowed() {
    assertFalse("containsKey(null) should return false", getMap().containsKey(null));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testContainsEntryYes() {
    assertTrue(multimap().containsEntry(k0(), v0()));
  }

  public void testContainsEntryNo() {
    assertFalse(multimap().containsEntry(k3(), v3()));
  }

  public void testContainsEntryAgreesWithGet() {
    for (K k : sampleKeys()) {
      for (V v : sampleValues()) {
        assertEquals(multimap().get(k).contains(v), multimap().containsEntry(k, v));