R apply(double from, long index);
  }

  /**
   * Returns the last element of the specified stream, or {@link java.util.Optional#empty} if the
   * stream is empty.
   *
   * <p>Equivalent to {@code stream.reduce((a, b) -> b)}, but may perform significantly better. This
   * method's runtime will be between O(log n) and O(n), performing better on <a

   *
   * @param deque the deque to be wrapped in a synchronized view
   * @return a synchronized view of the specified deque
   * @since 15.0
   */
  @J2ktIncompatible // Synchronized
  public static <E extends @Nullable Object> Deque<E> synchronizedDeque(Deque<E> deque) {
    return Synchronized.deque(deque, null);
  }

     */
    abstract @Nullable N visitNext(Deque<Iterator<? extends N>> horizon);
  }

  /** Poor man's method reference for {@code Deque::addFirst} and {@code Deque::addLast}. */
  private enum InsertionOrder {
    FRONT {
      @Override
      <T> void insertInto(Deque<T> deque, T value) {
        deque.addFirst(value);
      }
    },
    BACK {
      @Override

Doing this provides the following specific benefits:
- **Reduce the API surface** - We no longer need to maintain two methods.
- **Consistency** - All languages have consistent access to the same APIs and ergonomics in the DSL.
- **Reduce the size of the Gradle distribution** - We no longer need to carry multiple standard libraries for different languages.

## Decision

      if (connection.noNewExchanges) {
        assertThat(eventSequence).matchesPredicate { deque ->
          deque.any { it is NoNewExchanges && it.connection == connection }
        }
      }
    }

    logEvent(ConnectionEvent.ConnectionReleased(System.nanoTime(), connection, call))
  }

android.useAndroidX=true
kotlin.mpp.applyDefaultHierarchyTemplate=false

androidBuild=false
graalBuild=false
loomBuild=false
containerTests=false
okhttpModuleTests=false
okhttpDokka=false

# Increase heap and metaspace to reduce GC pressure when loading 30+ plugin classpaths
org.gradle.jvmargs=-Dfile.encoding=UTF-8

# AGP 9.0 Settings
android.builtInKotlin=true

PYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(".")[:2])


sequence_annotation_to_type = {
    Sequence: list,
    list: list,
    tuple: tuple,
    set: set,
    frozenset: frozenset,
    deque: deque,
}

sequence_types: tuple[type[Any], ...] = tuple(sequence_annotation_to_type.keys())


# Copy of Pydantic: pydantic/_internal/_utils.py with added TypeGuard
def lenient_issubclass(

import static org.codelibs.core.collection.CollectionsUtil.newLinkedList;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.beans.Introspector;
import java.util.Deque;

/**
 * Utility class for disposing of resources at the end of an application.
 * <p>
 * If there are resources that must be disposed of at the end of the application,

import dataclasses
import datetime
from collections import defaultdict, deque
from collections.abc import Callable
from decimal import Decimal
from enum import Enum
from ipaddress import (
    IPv4Address,
    IPv4Interface,
    IPv4Network,
    IPv6Address,
    IPv6Interface,
    IPv6Network,
)
from pathlib import Path, PurePath
from re import Pattern
from types import GeneratorType
from typing import Annotated, Any

package okhttp3

import assertk.assertThat
import assertk.assertions.isCloseTo
import assertk.assertions.isFalse
import assertk.assertions.isInstanceOf
import assertk.assertions.matchesPredicate
import java.util.Deque
import java.util.concurrent.ConcurrentLinkedDeque
import java.util.concurrent.TimeUnit
import okhttp3.CallEvent.CallStart
import okhttp3.CallEvent.Canceled
import org.junit.jupiter.api.Assertions.fail