*     partitions
   * @throws IllegalArgumentException if {@code size} is nonpositive
   */
  public static <T extends @Nullable Object> UnmodifiableIterator<List<T>> partition(
      Iterator<T> iterator, int size) {
    return partitionImpl(iterator, size, false);
  }

  /**

pkg syscall (freebsd-386), type Statfs_t struct, Mntonname [1024]int8
pkg syscall (freebsd-386-cgo), const S_IRWXG = 56
pkg syscall (freebsd-386-cgo), const S_IRWXG ideal-int
pkg syscall (freebsd-386-cgo), const S_IRWXO = 7
pkg syscall (freebsd-386-cgo), const S_IRWXO ideal-int
pkg syscall (freebsd-386-cgo), func Fstatat(int, string, *Stat_t, int) error

    } else {
      toIndex = ranges.size();
    }
    int length = toIndex - fromIndex;
    if (length == 0) {
      return ImmutableList.of();
    } else {
      return new ImmutableList<Range<C>>() {
        @Override
        public int size() {
          return length;
        }

        @Override
        public Range<C> get(int index) {
          checkElementIndex(index, length);

   * @since 32.0.0
   */
  public static void rotate(boolean[] array, int distance, int fromIndex, int toIndex) {
    // See Ints.rotate for more details about possible algorithms here.
    checkNotNull(array);
    checkPositionIndexes(fromIndex, toIndex, array.length);
    if (array.length <= 1) {
      return;
    }

    int length = toIndex - fromIndex;

    public SampleIntegers() {
      super((int) 0, (int) 1, (int) 2, (int) 3, (int) 4);
    }
  }

   * are read. Otherwise, the first byte read is stored into element {@code b[off]}, the next one
   * into {@code b[off+1]}, and so on. The number of bytes read is, at most, equal to {@code len}.
   *
   * @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

   * it slower than the native version.
   *
   * @param input the input bytes
   * @param offset the offset into the array at which to start reading
   * @param length the number of bytes from the input to read
   * @return a long of a concatenated 8 bytes
   */
  static long load64Safely(byte[] input, int offset, int length) {
    long result = 0;

     * separator.
     */
    abstract int separatorStart(int start);

    /**
     * Returns the first index in {@code toSplit} after {@code separatorPosition} that does not
     * contain a separator. This method is only invoked after a call to {@code separatorStart}.
     */
    abstract int separatorEnd(int separatorPosition);

    int offset = 0;
    int limit;

 * @param smallElementAggregateFunction the function used to aggregate tiny elements into a large bucket
 * @param expectedBucketNumber the return value's size should be expectedBucketNumber
 */
fun <T, R> splitIntoBuckets(
    list: LinkedList<T>,
    toIntFunction: (T) -> Int,
    largeElementSplitFunction: (T, Int) -> List<R>,

@NullUnmarked
public class IntMathBenchmark {
  private static final int[] exponent = new int[ARRAY_SIZE];
  private static final int[] factorial = new int[ARRAY_SIZE];
  private static final int[] binomial = new int[ARRAY_SIZE];
  private static final int[] positive = new int[ARRAY_SIZE];
  private static final int[] nonnegative = new int[ARRAY_SIZE];
  private static final int[] ints = new int[ARRAY_SIZE];

  @BeforeExperiment
  void setUp() {