int safeShift = Math.min(MAX_BACKOFF_SHIFT, Math.max(0, retryCount - 1));
                    long multiplier = 1L << safeShift;
                    // Check for potential overflow before multiplication
                    long delay = (retryDelayMs > Long.MAX_VALUE / multiplier) ? MAX_RETRY_DELAY
                            : Math.min(MAX_RETRY_DELAY, retryDelayMs * multiplier);

@NullUnmarked
public class StopwatchBenchmark {
  @Benchmark
  long stopwatch(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      Stopwatch s = Stopwatch.createStarted();
      // here is where you would do something
      total += s.elapsed(NANOSECONDS);
    }
    return total;
  }

  @Benchmark
  long manual(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {

     * @param operation the operation name
     * @throws ArithmeticException if operation would overflow
     */
    public static void validateIntegerAddition(int a, int b, String operation) {
        long result = (long) a + (long) b;
        if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
            throw new ArithmeticException(operation + " would cause integer overflow: " + a + " + " + b);
        }
    }

        return wasInUse;
    }

    @Override
    protected long makeKey(final Request request) throws IOException {
        long m = this.mid.incrementAndGet() - 1;
        if (!this.smb2) {
            m = m % 32000;
        }
        ((CommonServerMessageBlock) request).setMid(m);
        return m;
    }

    @Override
    protected Long peekKey() throws IOException {
        do {

    }

    /**
     * Returns a new array with the specified long value appended to the end of the long array.
     *
     * @param array
     *            the array. Must not be {@literal null}
     * @param value
     *            the value to add
     * @return a new array with the value appended
     */
    public static long[] add(final long[] array, final long value) {
        assertArgumentNotNull("array", array);

    // Won't compile: map.putInstance(Double.class, new Long(42));
  }

  public void testNull() {
    assertThrows(NullPointerException.class, () -> map.put(null, new Integer(1)));
    map.putInstance(Integer.class, null);
    assertNull(map.get(Integer.class));
    assertNull(map.getInstance(Integer.class));

    map.put(Long.class, null);
    assertNull(map.get(Long.class));
    assertNull(map.getInstance(Long.class));

  }

  @Test fun clientTwoFrameHelloWithPongs() {
    data.write("010348656c".decodeHex()) // Hel
    data.write("8a00".decodeHex()) // Pong
    data.write("8a00".decodeHex()) // Pong
    data.write("8a00".decodeHex()) // Pong
    data.write("8a00".decodeHex()) // Pong
    data.write("80026c6f".decodeHex()) // lo
    clientReader.processNextFrame()
    callback.assertPong(EMPTY)
    callback.assertPong(EMPTY)

     *
     * @param remoteKey remote memory key for RDMA access (token)
     * @param address remote memory address (offset)
     * @param length length of the memory region
     */
    public RdmaChannelInfo(int remoteKey, long address, int length) {
        // Create SMB2_RDMA_TRANSFORM structure
        this.transform = new Smb2RdmaTransform(address, remoteKey, length);
    }

    /**
     * Create from SMB2 RDMA Transform
     *

     */
    public void setOffset(final long offset) {
        this.offset = offset;
    }

    /**
     * Add RDMA channel information for direct memory access
     *
     * @param remoteKey remote memory key
     * @param address remote memory address
     * @param length length of memory region
     */
    public void addRdmaChannelInfo(int remoteKey, long address, int length) {

        long flags = 0x1234567890ABCDEFL;
        request.setSmbCreateFlags(flags);

        byte[] buffer = new byte[1024];
        request.writeBytesWireFormat(buffer, 0);

        // Verify flags are written at correct offset (8-15)
        long readFlags = 0;
        for (int i = 0; i < 8; i++) {
            readFlags |= ((long) (buffer[8 + i] & 0xFF)) << (i * 8);
        }