putByte(bytes[off + i]);
      }
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putBytes(ByteBuffer buffer) {
      ByteOrder bo = buffer.order();
      buffer.order(ByteOrder.LITTLE_ENDIAN);
      while (buffer.remaining() >= 4) {
        putInt(buffer.getInt());
      }
      while (buffer.hasRemaining()) {
        putByte(buffer.get());
      }

  }

  @Override
  public HashCode hashInt(int input) {
    return hashBytes(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(input).array());
  }

  @Override
  public HashCode hashLong(long input) {
    return hashBytes(ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(input).array());
  }

  @Override
  public HashCode hashUnencodedChars(CharSequence input) {

import static com.google.common.truth.Truth.assertThat;
import static java.nio.charset.StandardCharsets.UTF_8;

import com.google.common.hash.HashTestUtils.HashFn;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/** Tests for {@link Murmur3_128HashFunction}. */
@NullUnmarked
public class Murmur3Hash128Test extends TestCase {

import static java.lang.Byte.toUnsignedInt;

import com.google.errorprone.annotations.Immutable;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.jspecify.annotations.Nullable;

/**
 * See MurmurHash3_x64_128 in <a href="http://smhasher.googlecode.com/svn/trunk/MurmurHash3.cpp">the
 * C++ implementation</a>.
 *
 * @author Austin Appleby

       * which will have an efficient native implementation in JDK 9.
       *
       */
      String arch = System.getProperty("os.arch");
      if (Objects.equals(arch, "amd64")) {
        return ByteOrder.nativeOrder().equals(ByteOrder.LITTLE_ENDIAN)
            ? UnsafeByteArray.UNSAFE_LITTLE_ENDIAN
            : UnsafeByteArray.UNSAFE_BIG_ENDIAN;
      }
    } catch (Throwable t) {
      // ensure we really catch *everything*

encoded // form is reduced modulo l. func isReduced(s []byte) bool { if len(s) != 32 { return false } s0 := byteorder.LEUint64(s[:8]) s1 := byteorder.LEUint64(s[8:16]) s2 := byteorder.LEUint64(s[16:24]) s3 := byteorder.LEUint64(s[24:]) l0 := byteorder.LEUint64(scalarMinusOneBytes[:8]) l1 := byteorder.LEUint64(scalarMinusOneBytes[8:16]) l2 := byteorder.LEUint64(scalarMinusOneBytes[16:24]) l3 := byteorder.LEUint64(scalarMinusOneBytes[24:]) // Do a constant time subtraction chain scalarMinusOneBytes - s. If...

import com.google.common.primitives.Longs;
import com.google.common.testing.EqualsTester;
import com.google.common.testing.SerializableTester;
import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.DoubleSummaryStatistics;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for {@link Stats}. This tests instances created by both {@link Stats#of} and {@link

      "UnnecessaryJavacSuppressWarnings"
    })
    @VisibleForTesting
    enum UnsafeComparator implements LexicographicalComparator {
      INSTANCE;

      static final boolean BIG_ENDIAN = ByteOrder.nativeOrder().equals(ByteOrder.BIG_ENDIAN);

      /*
       * The following static final fields exist for performance reasons.
       *