System.arraycopy(values.array, values.start, array, count, values.length());
      count += values.length();
      return this;
    }

    private void ensureRoomFor(int numberToAdd) {
      int newCount = count + numberToAdd; // TODO(kevinb): check overflow now?
      if (newCount > array.length) {
        array = Arrays.copyOf(array, expandedCapacity(array.length, newCount));
      }
    }

    return Arrays.stream(array, start, end);
  }

  /** Returns a new, mutable copy of this array's values, as a primitive {@code int[]}. */
  public int[] toArray() {
    return Arrays.copyOfRange(array, start, end);
  }

  /**
   * Returns a new immutable array containing the values in the specified range.
   *

      this.array = new Object[mask + 1];
      for (int i = 0; i < array.length; i++) {
        array[i] = supplier.get();
      }
    }

    @SuppressWarnings("unchecked") // we only put L's in the array
    @Override
    public L getAt(int index) {
      return (L) array[index];
    }

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

  /**

        assertSame(data, blob.get(), "get() should expose the same array reference passed in");
        assertEquals(data.length, blob.length(), "length() should match underlying array length");
        assertEquals("deadbeef", blob.toString(), "toString() should reflect underlying content");
        assertEquals(data.hashCode(), blob.hashCode(), "hashCode should equal the array's hashCode");
    }

   *     in an {@code int}
   */
  public static char[] concat(char[]... arrays) {
    long length = 0;
    for (char[] array : arrays) {
      length += array.length;
    }
    char[] result = new char[checkNoOverflow(length)];
    int pos = 0;
    for (char[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

   *     in an {@code int}
   */
  public static float[] concat(float[]... arrays) {
    long length = 0;
    for (float[] array : arrays) {
      length += array.length;
    }
    float[] result = new float[checkNoOverflow(length)];
    int pos = 0;
    for (float[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;

   *     in an {@code int}
   */
  public static double[] concat(double[]... arrays) {
    long length = 0;
    for (double[] array : arrays) {
      length += array.length;
    }
    double[] result = new double[checkNoOverflow(length)];
    int pos = 0;
    for (double[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }

   * b, c}}.
   *
   * @param arrays zero or more {@code boolean} 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 boolean[] concat(boolean[]... arrays) {
    long length = 0;
    for (boolean[] array : arrays) {

   * b, c}}.
   *
   * @param arrays zero or more {@code boolean} 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 boolean[] concat(boolean[]... arrays) {
    long length = 0;
    for (boolean[] array : arrays) {

   *     in an {@code int}
   */
  public static short[] concat(short[]... arrays) {
    long length = 0;
    for (short[] array : arrays) {
      length += array.length;
    }
    short[] result = new short[checkNoOverflow(length)];
    int pos = 0;
    for (short[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;