AvlNode<E> next = current.succ();

        current.elemCount = 0;
        // Also clear these fields so that one deleted Entry doesn't retain all elements.
        current.left = null;
        current.right = null;
        current.pred = null;
        current.succ = null;

        current = next;
      }
      successor(header, header);

    Exception getException();

    /**
     * Sets an exception for this response.
     *
     * @param e the exception to set
     */
    void exception(Exception e);

    /**
     * Gets the next response in the chain.
     *
     * @return chained response
     */
    Response getNextResponse();

 */
fun interface Dns {
  /**
   * Returns the IP addresses of `hostname`, in the order they will be attempted by OkHttp. If a
   * connection to an address fails, OkHttp will retry the connection with the next address until
   * either a connection is made, the set of IP addresses is exhausted, or a limit is exceeded.
   */
  @Throws(UnknownHostException::class)
  fun lookup(hostname: String): List<InetAddress>

    } while (inflater.bytesRead < totalBytesToRead && !inflater.finished())

    // The inflater data was self-terminated and there's unexpected trailing data. Tear it all down
    // so we don't leak that data into the input of the next message.
    if (inflater.bytesRead < totalBytesToRead) {
      deflatedBytes.clear()
      inflaterSource.close()
      this.inflaterSource = null
      this.inflater = null
    }
  }

        }

        @Override
        public CommonServerMessageBlockRequest split() {
            return null;
        }

        @Override
        public boolean allowChain(CommonServerMessageBlockRequest next) {
            return true;
        }

        @Override
        public CommonServerMessageBlockRequest createCancel() {
            return null;
        }

        @Override

    return Iterators.pollNext(descendingIterator());
  }

  @ParametricNullness
  protected E standardFirst() {
    return iterator().next();
  }

  @ParametricNullness
  protected E standardLast() {
    return descendingIterator().next();
  }

  @Override
  public NavigableSet<E> descendingSet() {
    return delegate().descendingSet();
  }

  /**

        INLINE, // inline, each "internal" problem one line next to mojo invocation
        SUMMARY, // at end, list of plugin GAVs along with ANY validation issues
        BRIEF, // each "internal" problem one line next to mojo invocation
        // and at end list of plugin GAVs along with "external" issues

    assertThrows(
        ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          getList().remove(getNumElements() / 2);
          iterator.next();
        });
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveAtIndex_last() {
    runRemoveTest(getNumElements() - 1);
  }

        ConcurrentModificationException.class,
        () -> {
          Iterator<E> iterator = collection.iterator();
          assertTrue(collection.removeIf(Predicate.isEqual(samples.e0())));
          iterator.next();
        });
  }

  @CollectionFeature.Require(absent = SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testRemoveIf_unsupportedEmptyCollection() {
    try {
      assertFalse(

		if offset >= int64(len(block)) {
			// Decrement offset.
			offset -= int64(len(block))
			continue
		}

		// Skip until offset.
		block = block[offset:]

		// Reset the offset for next iteration to read everything
		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.
		if write < int64(len(block)) {
			n, err := dst.Write(block[:write])