* header blocks, we need to keep track of the smallest value in that interval.
       */
      private var smallestHeaderTableSizeSetting = Integer.MAX_VALUE
      private var emitDynamicTableSizeUpdate: Boolean = false

      @JvmField var maxDynamicTableByteCount: Int = headerTableSizeSetting

      // Visible for testing.

      extends TestIntegerListGenerator {
    @Override
    protected List<Integer> create(Integer[] elements) {
      Integer[] suffix = {Integer.MIN_VALUE, Integer.MAX_VALUE};
      Integer[] all = concat(elements, suffix);
      return makeArray(all).subArray(0, elements.length).asList();
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only from suite

  /** Counts the bytes in the given input stream using skip if possible. */
  private long countBySkipping(InputStream in) throws IOException {
    long count = 0;
    long skipped;
    while ((skipped = skipUpTo(in, Integer.MAX_VALUE)) > 0) {
      count += skipped;
    }
    return count;
  }

  /**
   * Copies the contents of this byte source to the given {@code OutputStream}. Does not close
   * {@code output}.
   *

  /** Current calls carried by this connection. */
  val calls = mutableListOf<Reference<RealCall>>()

  /** Timestamp when `allocations.size()` reached zero. Also assigned upon initial connection. */
  var idleAtNs = Long.MAX_VALUE

  /**
   * Returns true if this is an HTTP/2 connection. Such connections can be used in multiple HTTP
   * requests simultaneously.
   */
  internal val isMultiplexed: Boolean

        if (rows == Integer.MIN_VALUE) {
            return scrollDown(Integer.MAX_VALUE);
        }
        return rows > 0 ? appendEscapeSequence('S', rows) : rows < 0 ? scrollDown(-rows) : this;
    }

    public Ansi scrollDown(final int rows) {
        if (rows == Integer.MIN_VALUE) {
            return scrollUp(Integer.MAX_VALUE);
        }

    }
    IllegalArgumentException expected =
        assertThrows(
            IllegalArgumentException.class,
            () -> builder.addAll(nCopies(Integer.MAX_VALUE - 50, "a")));
    assertThat(expected).hasMessageThat().contains("cannot store more than MAX_VALUE elements");
  }

   * worthwhile tradeoff in a browser.
   */
  public CharMatcher precomputed() {
    return Platform.precomputeCharMatcher(this);
  }

  private static final int DISTINCT_CHARS = Character.MAX_VALUE - Character.MIN_VALUE + 1;

  /**
   * This is the actual implementation of {@link #precomputed}, but we bounce calls through a method
   * on {@link Platform} so that we can have different behavior in GWT.
   *

        this.server.serverTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        int tzOffset = SMBUtil.readInt2(buffer, bufferIndex);
        // tzOffset is signed!
        if ( tzOffset > Short.MAX_VALUE ) {
            tzOffset = -1 * ( 65536 - tzOffset );
        }
        this.server.serverTimeZone = tzOffset;
        bufferIndex += 2;
        this.server.encryptionKeyLength = buffer[ bufferIndex++ ] & 0xFF;

    static final int DEFAULT_INITIAL_CAPACITY = 4;

    static int expandedCapacity(int oldCapacity, int minCapacity) {
      if (minCapacity < 0) {
        throw new IllegalArgumentException("cannot store more than MAX_VALUE elements");
      } else if (minCapacity <= oldCapacity) {
        return oldCapacity;
      }
      // careful of overflow!
      int newCapacity = oldCapacity + (oldCapacity >> 1) + 1;

            try {
                Properties props = new Properties();

                try (FileInputStream in = new FileInputStream(touchfile)) {
                    try (FileLock lock = in.getChannel().lock(0, Long.MAX_VALUE, true)) {
                        getLogger().debug("Reading resolution-state from: " + touchfile);
                        props.load(in);

                        return props;
                    }