*
   * @since 21.0
   */
  public static <T extends @Nullable Object, K, V>
      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
          Comparator<? super K> comparator,
          Function<? super T, ? extends K> keyFunction,
          Function<? super T, ? extends V> valueFunction) {
    return CollectCollectors.toImmutableSortedMap(comparator, keyFunction, valueFunction);
  }

  /**

        K key,
        BiFunction<? super K, ? super @Nullable V, ? extends @Nullable V> remappingFunction) {
      synchronized (mutex) {
        return delegate().compute(key, remappingFunction);
      }
    }

    @Override
    @CheckForNull
    public V merge(
        K key,
        @NonNull V value,
        BiFunction<? super @NonNull V, ? super @NonNull V, ? extends @Nullable V>

      implements SortedSet<E> {
    SynchronizedSortedSet(SortedSet<E> delegate, @CheckForNull Object mutex) {
      super(delegate, mutex);
    }

    @Override
    SortedSet<E> delegate() {
      return (SortedSet<E>) super.delegate();
    }

    @Override
    @CheckForNull
    public Comparator<? super E> comparator() {
      synchronized (mutex) {
        return delegate().comparator();
      }
    }

  public static <T extends @Nullable Object, K, V>
      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
          Comparator<? super K> comparator,
          Function<? super T, ? extends K> keyFunction,
          Function<? super T, ? extends V> valueFunction) {
    return CollectCollectors.toImmutableSortedMap(comparator, keyFunction, valueFunction);
  }

  /**

    assertAssignable(
        new TypeToken<ArrayList<? super Number>>() {}, new TypeToken<List<? super N11>>() {});

    // ? super Number
    assertNotAssignable(
        new TypeToken<ArrayList<N11>>() {}, new TypeToken<List<? super Number>>() {});
    assertAssignable(
        new TypeToken<ArrayList<Number>>() {}, new TypeToken<List<? super Number>>() {});
    assertAssignable(

        private final Deque<ActivationFrame> stk;

        ActivationWalker(Deque<ActivationFrame> stk, UnaryOperator<String> transformer) {
            super(transformer);
            this.stk = stk;
        }

        private ActivationFrame nextFrame(String property) {
            return new ActivationFrame(property, Optional.empty());
        }

      extends AbstractMultimap<K, V2> {
    final Multimap<K, V1> fromMultimap;
    final EntryTransformer<? super K, ? super V1, V2> transformer;

    TransformedEntriesMultimap(
        Multimap<K, V1> fromMultimap,
        final EntryTransformer<? super K, ? super V1, V2> transformer) {
      this.fromMultimap = checkNotNull(fromMultimap);
      this.transformer = checkNotNull(transformer);
    }

    assertAssignable(
        new TypeToken<ArrayList<? super Number>>() {}, new TypeToken<List<? super N11>>() {});

    // ? super Number
    assertNotAssignable(
        new TypeToken<ArrayList<N11>>() {}, new TypeToken<List<? super Number>>() {});
    assertAssignable(
        new TypeToken<ArrayList<Number>>() {}, new TypeToken<List<? super Number>>() {});
    assertAssignable(

      implements StrongValueEntry<K, V, StrongKeyStrongValueEntry<K, V>> {
    @CheckForNull private volatile V value = null;

    private StrongKeyStrongValueEntry(K key, int hash) {
      super(key, hash);
    }

    @Override
    @CheckForNull
    public final V getValue() {
      return value;
    }

    private static final class LinkedStrongKeyStrongValueEntry<K, V>

      implements SortedSet<E> {

    FilteredSortedSet(SortedSet<E> unfiltered, Predicate<? super E> predicate) {
      super(unfiltered, predicate);
    }

    @Override
    @CheckForNull
    public Comparator<? super E> comparator() {
      return ((SortedSet<E>) unfiltered).comparator();
    }

    @Override