// Verify machineId part (should be truncated)
        byte[] expectedMachineId = new byte[32];
        for (int i = 0; i < 32; i++) {
            expectedMachineId[i] = (byte) i;
        }
        byte[] actualMachineId = new byte[32];
        System.arraycopy(value, 16, actualMachineId, 0, 32);
        assertArrayEquals(expectedMachineId, actualMachineId);
    }

	MOVHU.W	R3, 0x20(R4)         // MOVHU.W R3, 32(R4)        // b032e4e1
	MOVHU.P	R3, 0x20(R4)         // MOVHU.P R3, 32(R4)        // b032c4e0
	MOVH	R3, -0x20(R4)        // MOVH R3, -32(R4)          // b03244e1
	MOVH.W	R3, -0x20(R4)        // MOVH.W R3, -32(R4)        // b03264e1
	MOVH.P	R3, -0x20(R4)        // MOVH.P R3, -32(R4)        // b03244e0
	MOVHS	R3, -0x20(R4)        // MOVHS R3, -32(R4)         // b03244e1

	},
	{
		ObjectKey:  [32]byte{},
		ObjectInfo: ObjectInfo{ETag: "916516b396f0f4d4f2a0e7177557bec4-738"},
		ETag:       "916516b396f0f4d4f2a0e7177557bec4-738",
	},
	{
		ObjectKey:  [32]byte{},
		ObjectInfo: ObjectInfo{ETag: "916516b396f0f4d4f2a0e7177557bec4-Q"},
		ETag:       "",
		ShouldFail: true, // Q is not a number
	},
	{
		ObjectKey:  [32]byte{},

          if (supplementaryPlaneFix) { // bug compatibility: earlier versions did not have this add
            shift += 32;
          }
          len += 4;
        }

        if (shift >= 32) {
          int k1 = mixK1((int) buffer);
          h1 = mixH1(h1, k1);
          buffer = buffer >>> 32;
          shift -= 32;
        }
      }

      int k1 = mixK1((int) buffer);
      h1 ^= k1;

        // When
        int bytesWritten = request.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(32, bytesWritten);

        // Verify structure size (32)
        assertEquals(32, SMBUtil.readInt2(buffer, offset));

        // Verify notify flags
        assertEquals(Smb2ChangeNotifyRequest.SMB2_WATCH_TREE, SMBUtil.readInt2(buffer, offset + 2));

	VSLLVI		$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
	VSLLVI		$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
	VSRLVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
	VSRLVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
	VSRLVI		$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"

pkg math/bits (freebsd-386), const UintSize = 32
pkg math/bits (freebsd-386-cgo), const UintSize = 32
pkg math/bits (freebsd-amd64), const UintSize = 64
pkg math/bits (freebsd-amd64-cgo), const UintSize = 64
pkg math/bits (freebsd-arm), const UintSize = 32
pkg math/bits (freebsd-arm-cgo), const UintSize = 32
pkg math/bits (linux-386), const UintSize = 32
pkg math/bits (linux-386-cgo), const UintSize = 32
pkg math/bits (linux-amd64), const UintSize = 64

  }

  public void testAscending() {
    // Test 32 byte arrays of ascending.
    byte[] ascending = new byte[32];
    for (int i = 0; i < 32; i++) {
      ascending[i] = (byte) i;
    }
    assertCrc(0x46dd794e, ascending);
  }

  public void testDescending() {
    // Test 32 byte arrays of descending.
    byte[] descending = new byte[32];
    for (int i = 0; i < 32; i++) {
      descending[i] = (byte) (31 - i);
    }

    }
  }

  // goodFastHash(32) uses Murmur3_32. Use the same epsilon bounds.
  public void testGoodFastHash32() {
    HashTestUtils.check2BitAvalanche(Hashing.goodFastHash(32), 250, 0.20);
    HashTestUtils.checkAvalanche(Hashing.goodFastHash(32), 250, 0.17);
    HashTestUtils.checkNo2BitCharacteristics(Hashing.goodFastHash(32));
    HashTestUtils.checkNoFunnels(Hashing.goodFastHash(32));

  ChecksumHashFunction(
      ImmutableSupplier<? extends Checksum> checksumSupplier, int bits, String toString) {
    this.checksumSupplier = checkNotNull(checksumSupplier);
    checkArgument(bits == 32 || bits == 64, "bits (%s) must be either 32 or 64", bits);
    this.bits = bits;
    this.toString = checkNotNull(toString);
  }

  @Override
  public int bits() {
    return bits;
  }

  @Override