var bias = INITIAL_BIAS
    var h = b
    while (h < input.size) {
      val m = input.minBy { if (it >= n) it else Int.MAX_VALUE }

      val increment = (m - n) * (h + 1)
      if (delta > Int.MAX_VALUE - increment) return false // Prevent overflow.
      delta += increment

      n = m

      for (c in input) {
        if (c < n) {
          if (delta == Int.MAX_VALUE) return false // Prevent overflow.

  }

  public static LongAddable create() {
    return SUPPLIER.get();
  }

  private static final class PureJavaLongAddable extends AtomicLong implements LongAddable {
    @Override
    public void increment() {
      getAndIncrement();
    }

    @Override
    public void add(long x) {
      getAndAdd(x);
    }

    @Override
    public long sum() {
      return get();
    }
  }

import com.google.common.annotations.GwtCompatible;

/**
 * Abstract interface for objects that can concurrently add longs.
 *
 * @author Louis Wasserman
 */
@GwtCompatible
interface LongAddable {
  void increment();

  void add(long x);

  long sum();

  private fun readWindowUpdate(
    handler: Handler,
    length: Int,
    flags: Int,
    streamId: Int,
  ) {
    val increment: Long
    try {
      if (length != 4) throw IOException("TYPE_WINDOW_UPDATE length !=4: $length")
      increment = source.readInt() and 0x7fffffffL
      if (increment == 0L) throw IOException("windowSizeIncrement was 0")
    } catch (e: Exception) {

     * >= 0.5 and signifFloor is odd (which is true if both the 0.5 bit and the 1 bit are set).
     */
    boolean increment =
        (twiceSignifFloor & 1) != 0 && ((signifFloor & 1) != 0 || absX.getLowestSetBit() < shift);
    long signifRounded = increment ? signifFloor + 1 : signifFloor;
    long bits = (long) (exponent + EXPONENT_BIAS) << SIGNIFICAND_BITS;
    bits += signifRounded;
    /*

        Thread.sleep(200);

        // Check for leaks
        resourceManager.checkForLeaks();

        Map<String, Object> stats = resourceManager.getStatistics();
        // The leak counter may or may not increment depending on GC timing
        assertNotNull(stats.get("totalLeaks"));
    }

    private void createLeakyResource() {
        TestResource resource = new TestResource("leaky");

        }
    }

    @Nested
    @DisplayName("Resource management tests")
    class ResourceManagementTests {

        @Test
        @DisplayName("acquire should increment usage count")
        void shouldIncrementUsageCount() {
            long initial = transport.getUsageCount();
            transport.acquire();
            assertEquals(initial + 1, transport.getUsageCount());
        }

        if (oldValue == newValue) {
          return false;
        }
      } while (!data.compareAndSet(longIndex, oldValue, newValue));

      // We turned the bit on, so increment bitCount.
      bitCount.increment();
      return true;
    }

    boolean get(long bitIndex) {
      return (data.get((int) (bitIndex >>> LONG_ADDRESSABLE_BITS)) & (1L << bitIndex)) != 0;
    }

    /**

final class LongAddables {
  public static LongAddable create() {
    return new GwtLongAddable();
  }

  private static final class GwtLongAddable implements LongAddable {
    private long value;

    public void increment() {
      value++;
    }

    public void add(long x) {
      value += x;
    }

    public long sum() {
      return value;
    }
  }

// PrimaryKey returns the column is primary key or not.
func (ct ColumnType) PrimaryKey() (isPrimaryKey bool, ok bool) {
	return ct.PrimaryKeyValue.Bool, ct.PrimaryKeyValue.Valid
}

// AutoIncrement returns the column is auto increment or not.
func (ct ColumnType) AutoIncrement() (isAutoIncrement bool, ok bool) {
	return ct.AutoIncrementValue.Bool, ct.AutoIncrementValue.Valid
}

// Length returns the column type length for variable length column types