intsToAdd[i][j] = randomBigInteger(Integer.SIZE - 2).intValue();
        }
      } while (!Impl.GUAVA.noAddOverflow(intsToAdd[i][0], intsToAdd[i][1]));
      do {
        for (int j = 0; j < 2; j++) {
          longsToAdd[i][j] = randomBigInteger(Long.SIZE - 2).longValue();
        }
      } while (!Impl.GUAVA.noAddOverflow(longsToAdd[i][0], longsToAdd[i][1]));
      do {
        for (int j = 0; j < 2; j++) {

 */
@ElementTypesAreNonnullByDefault
final class DirectedGraphConnections<N, V> implements GraphConnections<N, V> {
  /**
   * A wrapper class to indicate a node is both a predecessor and successor while still providing
   * the successor value.
   */
  private static final class PredAndSucc {
    private final Object successorValue;

    PredAndSucc(Object successorValue) {
      this.successorValue = successorValue;

    @Override
    @CheckForNull
    protected EndpointPair<N> computeNext() {
      while (true) {
        /*
         * requireNonNull is safe because visitedNodes isn't cleared until this method calls
         * endOfData() (after which this method is never called again).
         */
        requireNonNull(visitedNodes);
        while (successorIterator.hasNext()) {
          N otherNode = successorIterator.next();

    private static void verifyZero ( int cnt, InputStream is ) throws IOException {
        byte[] offBuf = new byte[cnt];
        int pos = 0;
        while ( pos < cnt ) {
            int r = is.read(offBuf, pos, offBuf.length - pos);
            if ( r < 0 ) {
                fail("EOF while reading");
            }
            pos += r;
        }

        for ( int i = 0; i < offBuf.length; i++ ) {

      val code = CODES[symbol]
      val codeBitCount = CODE_BIT_COUNTS[symbol].toInt()

      accumulator = (accumulator shl codeBitCount) or code.toLong()
      accumulatorBitCount += codeBitCount

      while (accumulatorBitCount >= 8) {
        accumulatorBitCount -= 8
        sink.writeByte((accumulator shr accumulatorBitCount).toInt())
      }
    }

    if (accumulatorBitCount > 0) {

     * performs blocking reads for the incoming bytes.
     */
    @Throws(IOException::class)
    internal fun receive(
      source: BufferedSource,
      byteCount: Long,
    ) {
      lock.assertNotHeld()

      var remainingByteCount = byteCount

      while (remainingByteCount > 0L) {
        val finished: Boolean

 * common bugs: The {@code wait()} must be inside a {@code while} instead of an {@code if}, and
 * {@code notifyAll()} must be used instead of {@code notify()} because there are two different
 * logical conditions being awaited.
 *
 * <pre>{@code
 * public class SafeBox<V> {
 *   private V value;
 *
 *   public synchronized V get() throws InterruptedException {
 *     while (value == null) {
 *       wait();
 *     }

    assertIntact(q);
    q.remove(9);
    q.remove(11);
    q.remove(10);
    // Now we're in the critical state: [1, 15, 13, 8, 14]
    // Removing 8 while iterating caused duplicates in iteration result.
    List<Integer> result = Lists.newArrayListWithCapacity(initial.size());
    for (Iterator<Integer> iter = q.iterator(); iter.hasNext(); ) {
      Integer value = iter.next();

    // start substituting the arguments into the '%s' placeholders
    StringBuilder builder = new StringBuilder(template.length() + 16 * args.length);
    int templateStart = 0;
    int i = 0;
    while (i < args.length) {
      int placeholderStart = template.indexOf("%s", templateStart);
      if (placeholderStart == -1) {
        break;
      }
      builder.append(template.substring(templateStart, placeholderStart));

        position += copied;
        sourceChannel.position(position);
      } while (copied > 0 || position < sourceChannel.size());
      return position - oldPosition;
    }

    ByteBuffer buf = ByteBuffer.wrap(createBuffer());
    long total = 0;
    while (from.read(buf) != -1) {
      Java8Compatibility.flip(buf);
      while (buf.hasRemaining()) {
        total += to.write(buf);
      }