static {
        // fall back to the safer pure java implementation unless we're in
        // a 64-bit JVM with an 8-byte aligned field offset.
        if (!("64".equals(System.getProperty("sun.arch.data.model"))
            && (BYTE_ARRAY_BASE_OFFSET % 8) == 0
            // sanity check - this should never fail
            && theUnsafe.arrayIndexScale(byte[].class) == 1)) {

          private final ByteArrayOutputStream out = new ByteArrayOutputStream();

          @Override
          public boolean processBytes(byte[] buffer, int offset, int length) throws IOException {
            if (length >= 0) {
              out.write(buffer, offset, length);
            }
            return true;
          }

          @Override
          public byte[] getResult() {

    }

    @GwtIncompatible // not present in emulated superclass
    @Override
    int copyIntoArray(@Nullable Object[] dst, int offset) {
      for (ImmutableCollection<V> valueCollection : multimap.map.values()) {
        offset = valueCollection.copyIntoArray(dst, offset);
      }
      return offset;
    }

    @Override
    public int size() {
      return multimap.size();
    }

    @Override

    }

    @GwtIncompatible // not present in emulated superclass
    @Override
    int copyIntoArray(@Nullable Object[] dst, int offset) {
      for (ImmutableCollection<V> valueCollection : multimap.map.values()) {
        offset = valueCollection.copyIntoArray(dst, offset);
      }
      return offset;
    }

    @Override
    public int size() {
      return multimap.size();
    }

    @Override

   * the stream.
   *
   * @param in the input stream to read from.
   * @param b the buffer into which the data is read.
   * @param off an int specifying the offset into the data.
   * @param len an int specifying the number of bytes to read.
   * @throws EOFException if this stream reaches the end before reading all the bytes.
   * @throws IOException if an I/O error occurs.
   */

        assertThrows(IllegalStateException.class, () -> in.readUnsignedByte());
    assertThat(expected).hasCauseThat().isInstanceOf(EOFException.class);
  }

  public void testNewDataInput_offset() {
    ByteArrayDataInput in = ByteStreams.newDataInput(bytes, 2);
    assertEquals(0x56787654, in.readInt());
    assertThrows(IllegalStateException.class, () -> in.readInt());
  }

            params.put("Response Time", toNumberString(e.getResponseTime()));
            params.put("Hit Count", toNumberString(e.getHitCount()));
            params.put("Offset", toNumberString(e.getQueryOffset()));
            params.put("Page Size", toNumberString(e.getQueryPageSize()));
            params.put("Client IP", e.getClientIp());
            params.put("Referer", e.getReferer());

    /** The key of the configuration. e.g. span */
    String QUERY_HIGHLIGHT_FRAGMENTER = "query.highlight.fragmenter";

    /** The key of the configuration. e.g. -1 */
    String QUERY_HIGHLIGHT_FRAGMENT_OFFSET = "query.highlight.fragment.offset";

    /** The key of the configuration. e.g. 0 */
    String QUERY_HIGHLIGHT_NO_MATCH_SIZE = "query.highlight.no.match.size";

    /** The key of the configuration. e.g. score */

      }

      /*
       * Reclassify nodes in each list to new Map. Because we are using power-of-two expansion, the
       * elements from each bin must either stay at same index, or move with a power of two offset.
       * We eliminate unnecessary node creation by catching cases where old nodes can be reused
       * because their next fields won't change. Statistically, at the default threshold, only

    public synchronized PagingList<KuromojiItem> selectList(final int offset, final int size) {
        if (kuromojiItemList == null) {
            reload(null);
        }

        if (offset >= kuromojiItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<KuromojiItem> emptyList(), offset, size, kuromojiItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > kuromojiItemList.size()) {