@Override
  public void write(int b) throws IOException {
    hasher.putByte((byte) b);
    out.write(b);
  }

  @Override
  public void write(byte[] bytes, int off, int len) throws IOException {
    hasher.putBytes(bytes, off, len);
    out.write(bytes, off, len);
  }

  /**
   * Returns the {@link HashCode} based on the data written to this stream. The result is

     * PUTs the source byte array to target URI. The target MUST BE relative from the
     * {@link RemoteRepository#getUrl()} root.
     *
     * @throws RuntimeException If PUT fails for any reason.
     */
    void putBytes(@Nonnull byte[] source, @Nonnull URI relativeTarget);

    /**
     * PUTs the source string to target URI. The target MUST BE relative from the
     * {@link RemoteRepository#getUrl()} root.
     *

    for (int i = 0; i < reps; i++) {
      res +=
          System.identityHashCode(
              hashFunctionEnum
                  .getHashFunction()
                  .newHasher()
                  .putBytes(strings[i & SAMPLE_MASK].getBytes(StandardCharsets.UTF_8))
                  .hash());
    }
    return res;
  }

        public GuavaProcessor(Hasher hasher) {
            this.hasher = hasher;
        }

        @Override
        public void process(byte[] input, Blackhole blackhole) {
            hasher.putBytes(input);
            blackhole.consume(hasher.hash());
        }
    }

        .putChar((char) 0x0100)
        .putChar((char) 0x0000)
        .putChar((char) 0x0000);
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher.putBytes(new byte[] {0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00});
    assertEquals(hashCode, hasher.hash().asLong());

    hasher = HASH_FN.newHasher();
    hasher.putLong(0x0000000001000101L);

    assertEquals(
        String.format("expected: %08x, actual: %08x", expectedCrc, actualCrc),
        expectedCrc,
        actualCrc);
    int actualCrcHasher = Hashing.crc32c().newHasher().putBytes(data).hash().asInt();
    assertEquals(
        String.format("expected: %08x, actual: %08x", expectedCrc, actualCrc),
        expectedCrc,
        actualCrcHasher);
  }

        def name = file.name - '.class'
        def hasher = Hashing.md5().newHasher()
        dir.listFiles().findAll { it.name.startsWith(name) && it.name.endsWith('.class') }.sort().each {
            hasher.putBytes(it.bytes)
        }
        hasher.hash()
    }

                return Arrays.toString((byte[]) array);
            }

            @Override
            public void appendTo(Hasher hasher, Object array) {
                hasher.putBytes((byte[]) array);
            }

            @Override
            public void encode(Encoder encoder, Object array) throws IOException {
                encoder.writeBinary((byte[]) array);
            }

        get() = secretKey != null

    override val encryptionKeyHashCode: HashCode by lazy {
        secretKey?.let {
            Hashing.sha512().newHasher().apply {
                putBytes(it.encoded)
                putString(encryptionAlgorithm.transformation)
            }.hash()
        } ?: Hashing.newHasher().hash()
    }

    private
    fun shouldEncryptStreams(stateType: StateType) =

        @Override
        public byte[] toByteArray() {
            return bytes.clone();
        }

        @Override
        void appendToHasher(PrimitiveHasher hasher) {
            hasher.putBytes(bytes);
        }

        @Override
        public int hashCode() {
            return (bytes[0] & 0xFF)
                | ((bytes[1] & 0xFF) << 8)
                | ((bytes[2] & 0xFF) << 16)