abstract class Class2 extends Class1 implements Interface12 {}
    abstract class Class3<T> extends Class2 implements Interface3<T> {}
    TypeToken<Class3<String>>.TypeSet types = new TypeToken<Class3<String>>() {}.getTypes();
    makeUnmodifiable(types.rawTypes())
        .containsExactly(
            Class3.class,
            Interface3.class,
            Iterable.class,
            Class2.class,

      CallStart::class,
      ProxySelectStart::class,
      ProxySelectEnd::class,
      DnsStart::class,
      DnsEnd::class,
      ConnectStart::class,
      ConnectEnd::class,
      ConnectionAcquired::class,
      RequestHeadersStart::class,
      RequestHeadersEnd::class,
      ResponseHeadersStart::class,
      ResponseHeadersEnd::class,
      FollowUpDecision::class,

}

public abstract interface class okhttp3/Call$Factory {
	public abstract fun newCall (Lokhttp3/Request;)Lokhttp3/Call;
}

public abstract interface class okhttp3/Callback {
	public abstract fun onFailure (Lokhttp3/Call;Ljava/io/IOException;)V
	public abstract fun onResponse (Lokhttp3/Call;Lokhttp3/Response;)V
}

public final class okhttp3/CertificatePinner {

    assertThrows(UnsupportedOperationException.class, () -> map.subMap("a", "z").keySet().add("a"));
    assertThrows(UnsupportedOperationException.class, () -> map.tailMap("a").keySet().add("a"));
    assertThrows(UnsupportedOperationException.class, () -> map.headMap("r").keySet().add("a"));
    assertThrows(
        UnsupportedOperationException.class, () -> map.headMap("r").tailMap("m").keySet().add("a"));
  }

div[class="collapse"]{
width:100% !important;
}

td[class="logo_space"]{
height:12px !important;
}

span[class="address"]{
display:block !important;
width:240px !important;
}
td[class="cut"]{
display:none !important;
}

td[class="logo"]{
width:40px !important;
}

td[class="logo"] img {
width:24px !important;
}

img[class="media"]{
width:100% !important;
}

    assertThrows(InvalidCacheLoadException.class, () -> cache.get(new Object()));
    stats = cache.stats();
    assertThat(stats.missCount()).isEqualTo(1);
    assertThat(stats.loadSuccessCount()).isEqualTo(0);
    assertThat(stats.loadExceptionCount()).isEqualTo(1);
    assertThat(stats.hitCount()).isEqualTo(0);

    assertThrows(InvalidCacheLoadException.class, () -> cache.getUnchecked(new Object()));

 * @author Kevin Bourrillion
 * @author Jared Levy
 * @author Chris Povirk
 * @since 2.0
 */
@GwtCompatible
public final class Sets {
  private Sets() {}

  /**
   * {@link AbstractSet} substitute without the potentially-quadratic {@code removeAll}
   * implementation.
   */
  abstract static class ImprovedAbstractSet<E extends @Nullable Object> extends AbstractSet<E> {
    @Override
    public boolean removeAll(Collection<?> c) {

 *
 * @author Kevin Bourrillion
 * @author Nishant Thakkar
 * @author Sven Mawson
 * @since 1.0
 */
@GwtCompatible
public final class Futures extends GwtFuturesCatchingSpecialization {

  // A note on memory visibility.
  // Many of the utilities in this class (transform, withFallback, withTimeout, asList, combine)
  // have two requirements that significantly complicate their design.

@J2ktIncompatible
@GwtIncompatible // TODO(dpb): GWT compatibility.
public final class ClosingFuture<V extends @Nullable Object> {

  private static final LazyLogger logger = new LazyLogger(ClosingFuture.class);

  /**
   * An object that can capture objects to be closed later, when a {@link ClosingFuture} pipeline is
   * done.
   */
  public static final class DeferredCloser {
    @RetainedWith private final CloseableList list;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

/**
 * The API manager for search operations.
 */
public class SearchApiManager extends BaseApiManager {

    private static final Logger logger = LogManager.getLogger(SearchApiManager.class);

    /**
     * The message field.
     */
    protected static final String MESSAGE_FIELD = "message";

    /**
     * The result field.