final <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>
          A result(Collector<T, A, R> collector, Iterable<T> inputs) {
        A accum = collector.supplier().get();
        for (T input : inputs) {
          collector.accumulator().accept(accum, input);
        }
        return accum;
      }
    },
    /** Get one accumulator for each element and merge the accumulators left-to-right. */

  }

  @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) {
    int len = input.length();

mvn                eol=lf crlf=input
mvnDebug           eol=lf crlf=input

  }

  static void testSort(long[] input, long[] expected) {
    input = Arrays.copyOf(input, input.length);
    UnsignedLongs.sort(input);
    assertThat(input).isEqualTo(expected);
  }

  static void testSort(long[] input, int from, int to, long[] expected) {
    input = Arrays.copyOf(input, input.length);
    UnsignedLongs.sort(input, from, to);
    assertThat(input).isEqualTo(expected);
  }

    // from InputStream to OutputStream
    //
    /**
     * Copies from an input stream to an output stream.
     * <p>
     * Neither the input stream nor the output stream is closed.
     * </p>
     *
     * @param in the input stream (must not be {@literal null})
     * @param out the output stream (must not be {@literal null})
     * @return the number of bytes copied

            // Verify output buffer length
            assertEquals(0x8000, SMBUtil.readInt4(buffer, 68));

            // Verify input buffer offset (should be 0 when no input buffer)
            assertEquals(0, SMBUtil.readInt2(buffer, 72));

            // Verify input buffer length (should be 0 when no input buffer)
            assertEquals(0, SMBUtil.readInt4(buffer, 76));

            // Verify additional information

    }

    /**
     * Interface for building input locations during XML parsing.
     */
    public interface InputLocationBuilder {
        Object toInputLocation(XMLStreamReader parser);
    }

    /**
     * Implementation method for reading an XML node from an input stream.
     *
     * @param input the input stream to read from

        dummy += ORDERING.immutableSortedCopy(input).get(0);
      }
    }
    return dummy;
  }

  @Benchmark
  int sortedSet(int reps) {
    int dummy = 0;
    if (mutable) {
      for (int i = 0; i < reps; i++) {
        dummy += new TreeSet<Integer>(input).first();
      }
    } else {
      for (int i = 0; i < reps; i++) {
        dummy += ImmutableSortedSet.copyOf(input).first();
      }
    }

								</button>
							</div>
							<div class="input-footer">
								<span class="input-hint"><la:message key="labels.chat_input_hint" /></span>
								<span class="char-counter"><span id="charCount">0</span> / 4000</span>
							</div>
						</div>
					</div>
				</div>
			</div>
		</div>
	</main>
	<jsp:include page="../footer.jsp" />
	<input type="hidden" id="contextPath" value="${contextPath}" />

            // Process each input from the previous converter
            for (final String input : currentInputs) {
                if (resultSet.size() >= maxReadingNum) {
                    break;
                }

                // Convert the input and collect results
                final List<String> results = converter.convert(input, field, lang);
                if (results == null) {