return val;
    }

    /**
     * Encodes a long integer (4 bytes) in NDR format.
     *
     * @param l the long integer value to encode
     */
    public void enc_ndr_long(final int l) {
        align(4);
        Encdec.enc_uint32le(l, buf, index);
        advance(4);
    }

    /**
     * Decodes a long integer (4 bytes) from NDR format.
     *

          override fun contentLength(): Long = delegate.contentLength()

          @Throws(IOException::class)
          override fun writeTo(sink: BufferedSink) {
            val forwardingSink = object : ForwardingSink(sink) {
              private var totalBytesWritten: Long = 0
              private var completed = false

              override fun write(source: Buffer, byteCount: Long) {

final class OverflowAvoidingLockSupport {
  // Represents the max nanoseconds representable on a linux timespec with a 32 bit tv_sec
  static final long MAX_NANOSECONDS_THRESHOLD = (1L + Integer.MAX_VALUE) * 1_000_000_000L - 1L;

  private OverflowAvoidingLockSupport() {}

  static void parkNanos(@Nullable Object blocker, long nanos) {
    // Even in the extremely unlikely event that a thread unblocks itself early after only 68 years,

    }

    private ChannelInfo selectLeastLoaded(Collection<ChannelInfo> channels) {
        ChannelInfo leastLoadedChannel = null;
        long minPending = Long.MAX_VALUE;
        for (ChannelInfo channel : channels) {
            long pending = channel.getRequestsPending();
            if (pending < minPending) {
                minPending = pending;
                leastLoadedChannel = channel;

    public String id;

    /** Sequence number for ordering search list entries */
    @ValidateTypeFailure
    public Long seqNo;

    /** Primary term value for search list configuration */
    @ValidateTypeFailure
    public Long primaryTerm;

    /**
     * Default constructor for EditForm.
     */
    public EditForm() {
        super();
    }

   * [WindowCounter] generally carries the client view of total and acked bytes.
   */
  fun receivingStreamWindowChanged(
    streamId: Int,
    windowCounter: WindowCounter,
    bufferSize: Long,
  )

  /**
   * Notification that the receiving connection flow control window has changed.
   * [WindowCounter] generally carries the client view of total and acked bytes.
   */

import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,
): Cache = Cache(fileSystem, file, maxSize)

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {
    idleAtNs = value
  }

internal val Response.exchangeAccessor: Exchange?
  get() = this.exchange

    return Ints.compare(flip(a), flip(b));
  }

  /**
   * Returns the value of the given {@code int} as a {@code long}, when treated as unsigned.
   *
   * <p><b>Java 8+ users:</b> use {@link Integer#toUnsignedLong(int)} instead.
   */
  public static long toLong(int value) {
    return value & INT_MASK;
  }

  /**

@J2ObjCIncompatible // gc
@NullMarked
public final class GcFinalization {
  private GcFinalization() {}

  /**
   * 10 seconds ought to be long enough for any object to be GC'ed and finalized. Unless we have a
   * gigantic heap, in which case we scale by heap size.
   */
  private static long timeoutSeconds() {
    // This class can make no hard guarantees.  The methods in this class are inherently flaky, but

            }
            if (formal == Integer.TYPE && (actual == Integer.class || actual == Short.class || actual == Byte.class)) {
                return true;
            }
            if (formal == Long.TYPE
                    && (actual == Long.class
                            || actual == Integer.class
                            || actual == Short.class
                            || actual == Byte.class)) {
                return true;