for (float f : array) {
            hasher.putInt(Float.floatToRawIntBits(f));
        }
    }

    public static void putLongs(Hasher hasher, long[] array) {
        hasher.putInt(array.length);
        for (long l : array) {
            hasher.putLong(l);
        }
    }

    public static void putInts(Hasher hasher, int[] array) {
        hasher.putInt(array.length);
        for (int i : array) {

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

            @Override
            public void appendTo(Hasher hasher, Object array) {
                HasherExtensions.putLongs(hasher, (long[]) array);
            }

            @Override
            public void encode(Encoder encoder, Object array) throws IOException {

  @CanIgnoreReturnValue
  @Override
  Hasher putInt(int i);

  @CanIgnoreReturnValue
  @Override
  Hasher putLong(long l);

  /** Equivalent to {@code putInt(Float.floatToRawIntBits(f))}. */
  @CanIgnoreReturnValue
  @Override
  Hasher putFloat(float f);

  /** Equivalent to {@code putLong(Double.doubleToRawLongBits(d))}. */
  @CanIgnoreReturnValue
  @Override
  Hasher putDouble(double d);

            update(4);
        }

        @Override
        public void putLong(long value) {
            buffer.putLong(value);
            update(8);
        }

        @Override
        public void putDouble(double value) {
            long longValue = Double.doubleToRawLongBits(value);
            putLong(longValue);
        }

        @Override
        public void putBoolean(boolean value) {

    public static UniqueId from(UUID uuid) {
        long msb = uuid.getMostSignificantBits();
        long lsb = uuid.getLeastSignificantBits();

        byte[] bytes = new byte[16];
        ByteBuffer.wrap(bytes).putLong(msb).putLong(lsb);
        String value = ENCODING.encode(bytes);

        return new UniqueId(value);
    }

    public static UniqueId from(String string) {
        if (PATTERN.matcher(string).matches()) {

        for (Hasher hasher : hashers) {
          hasher.putInt(i);
        }
        return this;
      }

      @Override
      public Hasher putLong(long l) {
        for (Hasher hasher : hashers) {
          hasher.putLong(l);
        }
        return this;
      }

      @Override
      public Hasher putFloat(float f) {
        for (Hasher hasher : hashers) {

  @Override
  @CanIgnoreReturnValue
  public Hasher putInt(int i) {
    scratch.putInt(i);
    return update(Ints.BYTES);
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putLong(long l) {
    scratch.putLong(l);
    return update(Longs.BYTES);
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putChar(char c) {
    scratch.putChar(c);
    return update(Chars.BYTES);
  }

  @CanIgnoreReturnValue
  @Override
  Hasher putInt(int i);

  @CanIgnoreReturnValue
  @Override
  Hasher putLong(long l);

  /** Equivalent to {@code putInt(Float.floatToRawIntBits(f))}. */
  @CanIgnoreReturnValue
  @Override
  Hasher putFloat(float f);

  /** Equivalent to {@code putLong(Double.doubleToRawLongBits(d))}. */
  @CanIgnoreReturnValue
  @Override
  Hasher putDouble(double d);

  @CanIgnoreReturnValue
  public final Hasher putInt(int i) {
    buffer.putInt(i);
    munchIfFull();
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putLong(long l) {
    buffer.putLong(l);
    munchIfFull();
    return this;
  }

  @Override
  public final HashCode hash() {
    munch();
    Java8Compatibility.flip(buffer);
    if (buffer.remaining() > 0) {

  @CanIgnoreReturnValue
  public final Hasher putBoolean(boolean b) {
    return putByte(b ? (byte) 1 : (byte) 0);
  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putDouble(double d) {
    return putLong(Double.doubleToRawLongBits(d));
  }

  @Override
  @CanIgnoreReturnValue
  public final Hasher putFloat(float f) {
    return putInt(Float.floatToRawIntBits(f));
  }

  @Override
  @CanIgnoreReturnValue