}

  @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) {

 *
 * <p><b>Key-grouped iteration.</b> All view collections follow the same iteration order. In all
 * current implementations, the iteration order always keeps multiple entries with the same key
 * together. Any creation method that would customarily respect insertion order (such as {@link
 * #copyOf(Multimap)}) instead preserves key-grouped order by inserting entries for an existing key
 * immediately after the last entry having that key.
 *

        ByteBuffer bb = ByteBuffer.wrap(bytes).order(java.nio.ByteOrder.LITTLE_ENDIAN);

        // Read GUID components in little-endian order
        int data1 = bb.getInt(); // first 4 bytes (little-endian)
        short data2 = bb.getShort(); // next 2 bytes (little-endian)
        short data3 = bb.getShort(); // next 2 bytes (little-endian)

        // The last 8 bytes are read as big-endian (network byte order for the high/low parts)

		content_length, last_modified 및 mimetype입니다.
		설정에서 지정하는 필드는 변경할 수 있습니다.
	</dd>
	<dt>정렬</dt>
	<dd>
		sort 연산자는 지정된 필드 이름으로 문서를 정렬합니다.
		sort 연산자의 사용 방법은 sort:&lt;field&gt;.&lt;order&gt;입니다.
		&lt;order&gt; 는 asc 또는 desc 오름차순 · 내림차순을 지정할 수 있습니다.
		예를 들어, Fess를 포함한 문서 크기의 내림차순으로 정렬하려면 다음과 같이 입력합니다.
		<pre>Fess sort:content_length.desc</pre>
		기본으로 사용 가능한 필드는 created, content_length 및 last_modified됩니다.

    }
    return tmp;
  }

  @Benchmark
  long parseUnsignedLong(int reps) {
    long tmp = 0;
    // Given that we make three calls per pass, we scale reps down in order
    // to do a comparable amount of work to other measurements.
    int scaledReps = reps / 3 + 1;
    for (int i = 0; i < scaledReps; i++) {
      int j = i & ARRAY_MASK;

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A utility for testing an Iterator implementation by comparing its behavior to that of a "known
 * good" reference implementation. In order to accomplish this, it's important to test a great
 * variety of sequences of the {@link Iterator#next}, {@link Iterator#hasNext} and {@link
 * Iterator#remove} operations. This utility takes the brute-force approach of trying <i>all</i>

            int bytesEncoded = buffer.encode(dst, 0);

            assertEquals(buffer.size(), bytesEncoded);

            // Verify encoded data
            ByteBuffer bb = ByteBuffer.wrap(dst).order(ByteOrder.LITTLE_ENDIAN);
            assertEquals(maxReferralLevel, bb.getShort());

            // Verify path encoding (UTF-16LE)
            byte[] pathBytes = path.getBytes(StandardCharsets.UTF_16LE);

   */
  E[] createArray(int length);

  /**
   * Returns the iteration ordering of elements, given the order in which they were added to the
   * container. This method may return the original list unchanged, the original list modified in
   * place, or a different list.
   *
   * <p>If the order is non-deterministic, as with {@link java.util.HashSet}, this method can return

        """

        and:
        releaseNotes << """
Nothing to write about
        """

        when:

 * keys and values. The iteration order is preserved across non-distinct key values. For example,
 * for the following multimap definition:
 *
 * {@snippet :
 * Multimap<K, V> multimap = LinkedListMultimap.create();
 * multimap.put(key1, foo);
 * multimap.put(key2, bar);
 * multimap.put(key1, baz);
 * }
 *