}

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_REMOVE)
  /*
   * SetMultimap.asMap essentially returns a Map<K, Set<V>>; we just can't declare it that way.
   * Thus, calls like asMap().values().remove(someSet) are safe because they are comparing a set to
   * a collection of other sets.
   */
  @SuppressWarnings("CollectionUndefinedEquality")
  public void testValuesRemove() {

    }

    @LazyInit transient @Nullable Set<E> elementSet;

    Set<E> createElementSet() {
      return Collections.unmodifiableSet(delegate.elementSet());
    }

    @Override
    public Set<E> elementSet() {
      Set<E> es = elementSet;
      return (es == null) ? elementSet = createElementSet() : es;
    }

    @LazyInit transient @Nullable Set<Multiset.Entry<E>> entrySet;

    }

    @LazyInit transient @Nullable Set<E> elementSet;

    Set<E> createElementSet() {
      return Collections.unmodifiableSet(delegate.elementSet());
    }

    @Override
    public Set<E> elementSet() {
      Set<E> es = elementSet;
      return (es == null) ? elementSet = createElementSet() : es;
    }

    @LazyInit transient @Nullable Set<Multiset.Entry<E>> entrySet;

  @SuppressWarnings("GoodTime")
  long getAccessTime();

  /** Sets the entry access time in ns. */
  @SuppressWarnings("GoodTime") // b/122668874
  void setAccessTime(long time);

  /** Returns the next entry in the access queue. */
  ReferenceEntry<K, V> getNextInAccessQueue();

  /** Sets the next entry in the access queue. */
  void setNextInAccessQueue(ReferenceEntry<K, V> next);

    ImmutableSortedSet<Integer> set = ContiguousSet.create(Range.closed(1, 3), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));
    assertTrue(set.contains(3));
    assertFalse(set.contains(4));
    set = ContiguousSet.create(Range.open(0, 4), integers());
    assertFalse(set.contains(0));
    assertTrue(set.contains(1));
    assertTrue(set.contains(2));

   * of their natural ordering.
   */
  public static <E extends Comparable<?>> Builder<E> reverseOrder() {
    return new Builder<>(Collections.reverseOrder());
  }

  /**
   * Returns a builder that creates immutable sorted sets whose elements are ordered by their

            return false;
        }
        return true;
    }

    /**
     * Returns a set of matched label values.
     *
     * @param path The path to match.
     * @return A set of matched label values.
     */
    public Set<String> getMatchedLabelValueSet(final String path) {
        if (labelTypePatternList == null) {
            synchronized (this) {

    }

    /**
     * Sets whether there is a next page available.
     *
     * @param existNextPage true if next page exists, false otherwise
     */
    public void setExistNextPage(final boolean existNextPage) {
        this.existNextPage = existNextPage;
    }

    /**
     * Gets the number of records per page.
     * Returns the default page size if not set or invalid.
     *

    }

    /**
     * Sets the flag indicating if a next page exists.
     *
     * @param existNextPage true if next page exists, false otherwise
     */
    public void setExistNextPage(final boolean existNextPage) {
        this.existNextPage = existNextPage;
    }

    /**
     * Gets the number of records per page.
     * If page size is not set or invalid, returns the default page size.
     *

import com.google.common.collect.AbstractIterator;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import java.util.Iterator;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A class to facilitate the set returned by {@link Graph#edges()}.
 *
 * @author James Sexton
 */
abstract class EndpointPairIterator<N> extends AbstractIterator<EndpointPair<N>> {