// lines, bytes, UTF-8-encoded runes, and space-delimited words. The
// client may instead provide a custom split function.
//
// Scanning stops unrecoverably at EOF, the first I/O error, or a token too
// large to fit in the [Scanner.Buffer]. When a scan stops, the reader may have
// advanced arbitrarily far past the last token. Programs that need more
// control over error handling or large tokens, or must run sequential scans

   *       servers {@code alpha}, {@code bravo}, and {@code charlie} and you occasionally need to
   *       take each of the servers offline, {@code consistentHash} will be a poor fit: It provides
   *       no way for you to specify which of the three buckets is disappearing. Thus, if your
   *       buckets change from {@code [alpha, bravo, charlie]} to {@code [bravo, charlie]}, it will

			//
			// S3 uses B-encoding (Base64) for non-ASCII-heavy metadata and Q-encoding
			// (quoted-printable) for mostly ASCII strings. Long strings are split at word
			// boundaries to fit RFC 2047’s 75-character limit, ensuring HTTP parser
			// compatibility.
			//
			// However, this splitting increases header size and can introduce errors, unlike Go’s

   * @param arrays zero or more {@code long} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static long[] concat(long[]... arrays) {
    long length = 0;
    for (long[] array : arrays) {
      length += array.length;
    }

   * @param arrays zero or more {@code int} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static int[] concat(int[]... arrays) {
    long length = 0;
    for (int[] array : arrays) {
      length += array.length;
    }

   * @param arrays zero or more {@code char} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static char[] concat(char[]... arrays) {
    long length = 0;
    for (char[] array : arrays) {
      length += array.length;
    }

   * @param arrays zero or more {@code float} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static float[] concat(float[]... arrays) {
    long length = 0;
    for (float[] array : arrays) {
      length += array.length;
    }

     */
    const val CANCEL_AFTER_CLOSE_MILLIS = 60L * 1000

    /**
     * The smallest message that will be compressed. We use 1024 because smaller messages already
     * fit comfortably within a single ethernet packet (1500 bytes) even with framing overhead.
     *
     * For tests this must be big enough to realize real compression on test messages like

   * @param arrays zero or more {@code double} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static double[] concat(double[]... arrays) {
    long length = 0;
    for (double[] array : arrays) {
      length += array.length;
    }

    if (in.read() == -1) {
      // oh, there's the end of the stream
      return combineBuffers(bufs, MAX_ARRAY_LEN);
    } else {
      throw new OutOfMemoryError("input is too large to fit in a byte array");
    }
  }

  private static byte[] combineBuffers(Queue<byte[]> bufs, int totalLen) {
    if (bufs.isEmpty()) {
      return new byte[0];
    }
    byte[] result = bufs.remove();