if err := feedTokens(1); err != nil {
		return nil, err
	}
	numEntries, err := strconv.ParseInt(nextToken(), 10, 0) // Intentionally parse as native int
	if err != nil || numEntries < 0 || int(2*numEntries) < int(numEntries) {
		return nil, ErrHeader
	}

	// Parse for all member entries.
	// numEntries is trusted after this since feedTokens limits the number of

    /**
     * init graph
     */
    private void init(int nVertices, int nEdges) {
        int nV = nVertices;
        if (nVertices < 1) {
            nV = 1;
        }

        checkVertices(nV);

        int nE = nVertices;
        if (nEdges <= nV) {
            nE = 2 * nE;
        }

        checkEdges(nE);
    }

pkg math/rand/v2, func Float64() float64 #61716
pkg math/rand/v2, func Int() int #61716
pkg math/rand/v2, func Int32() int32 #61716
pkg math/rand/v2, func Int32N(int32) int32 #61716
pkg math/rand/v2, func Int64() int64 #61716
pkg math/rand/v2, func Int64N(int64) int64 #61716
pkg math/rand/v2, func IntN(int) int #61716
pkg math/rand/v2, func N[$0 intType]($0) $0 #61716
pkg math/rand/v2, func New(Source) *Rand #61716

  @Benchmark
  int factorial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += BigIntegerMath.factorial(factorials[j]).intValue();
    }
    return tmp;
  }

  @Benchmark
  int binomial(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & 0xffff;
      tmp += BigIntegerMath.binomial(factorials[j], binomials[j]).intValue();

        // parameters but this is sufficient for now. Ultimately we want components like Builders to provide a way to
        // extend the command line to accept its own configuration parameters.
        //
        if (context.options().threads().isPresent()) {
            int degreeOfConcurrency =

  /**
   * Sends a stream of data from the {@code from} object into the sink {@code into}. There is no
   * requirement that this data be complete enough to fully reconstitute the object later.
   *
   * @since 12.0 (in Guava 11.0, {@code PrimitiveSink} was named {@code Sink})
   */
  void funnel(@ParametricNullness T from, PrimitiveSink into);

 * @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>,
    smallElementAggregateFunction: (List<T>) -> R,

			db.RowsAffected++
			db.AddError(rows.Scan(values...))

			mapValue := map[string]interface{}{}
			scanIntoMap(mapValue, values, columns)
			*dest = append(*dest, mapValue)
		}
	case *int, *int8, *int16, *int32, *int64,
		*uint, *uint8, *uint16, *uint32, *uint64, *uintptr,
		*float32, *float64,
		*bool, *string, *time.Time,
		*sql.NullInt32, *sql.NullInt64, *sql.NullFloat64,

			// TryRead
			n, err = rb.TryRead(buf[:readRng.Intn(len(buf))])
			readBytes += n
			read.Write(buf[:n])
			debugln("READ 3\t", n, readBytes)
			if err != nil && err != ErrAcquireLock && err != ErrIsEmpty {
				readErr = err
				break
			}
			if doSleep && readRng.Intn(20) == 0 {
				time.Sleep(time.Duration(readRng.Intn(maxSleep)))
			}
		}
	}()

	// Writer
	{

	Size  int64
	N     int64
}

// Add a duration to a single element.
func (a *AccElem) add(dur time.Duration) {
	if dur < 0 {
		dur = 0
	}
	a.Total += int64(dur)
	a.N++
}

// Merge b into a.
func (a *AccElem) merge(b AccElem) {
	a.N += b.N
	a.Total += b.Total
	a.Size += b.Size
}

// Avg returns average time spent.
func (a AccElem) avg() time.Duration {
	if a.N >= 1 && a.Total > 0 {