/**
   * Discouraged synonym for {@link #compareFalseFirst}.
   *
   * @deprecated Use {@link #compareFalseFirst}; or, if the parameters passed are being either
   *     negated or reversed, undo the negation or reversal and use {@link #compareTrueFirst}.
   * @since 19.0
   */
  @InlineMe(replacement = "this.compareFalseFirst(left, right)")
  @Deprecated

    }

    /**
     * Returns a reversed view of a sequenced collection.
     *
     * @param <E> the element type
     * @param collection the sequenced collection
     * @return a reversed view of the collection
     * @since Java 21
     */
    public static <E> SequencedCollection<E> reversed(final SequencedCollection<E> collection) {
        return collection.reversed();
    }

    /**

  /** Returns a [toString] consistent with [Map], with elements in insertion order. */
  override fun toString(): String =
    generateSequence<LinkedTags<*>>(seed = this) { it.next as? LinkedTags<*> }
      .toList()
      .reversed()
      .joinToString(prefix = "{", postfix = "}") { "${it.key}=${it.value}" }
}

internal fun <T : Any> AtomicReference<Tags>.computeIfAbsent(
  type: KClass<T>,
  compute: () -> T,
): T {

    }

    private Comparator<MavenProject> createComparator() {
        return Comparator.comparingLong((ToLongFunction<MavenProject>) this::getProjectWeight)
                .reversed() // Higher weights first
                .thenComparing(this::getProjectId); // Secondary sort for deterministic ordering
    }

    private long calculateWeight(MavenProject project) {

 * that of its keys. This constraint enables bimaps to support an "inverse view", which is another
 * bimap containing the same entries as this bimap but with reversed keys and values.
 *
 * <h3>Implementations</h3>
 *
 * <ul>
 *   <li>{@link ImmutableBiMap}
 *   <li>{@link HashBiMap}
 *   <li>{@link EnumBiMap}
 *   <li>{@link EnumHashBiMap}
 * </ul>
 *

 * that of its keys. This constraint enables bimaps to support an "inverse view", which is another
 * bimap containing the same entries as this bimap but with reversed keys and values.
 *
 * <h3>Implementations</h3>
 *
 * <ul>
 *   <li>{@link ImmutableBiMap}
 *   <li>{@link HashBiMap}
 *   <li>{@link EnumBiMap}
 *   <li>{@link EnumHashBiMap}
 * </ul>
 *

  }

  // Graph mutation methods

  // Graph view methods

  /**
   * Returns a view of {@code graph} with the direction (if any) of every edge reversed. All other
   * properties remain intact, and further updates to {@code graph} will be reflected in the view.
   */
  public static <N> Graph<N> transpose(Graph<N> graph) {
    if (!graph.isDirected()) {

        getUpperEndpoint(),
        getUpperBoundType());
  }

  @LazyInit private transient @Nullable GeneralRange<T> reverse;

  /** Returns the same range relative to the reversed comparator. */
  GeneralRange<T> reverse() {
    GeneralRange<T> result = reverse;
    if (result == null) {
      result =
          new GeneralRange<>(
              reverseComparator(comparator),

        getUpperEndpoint(),
        getUpperBoundType());
  }

  @LazyInit private transient @Nullable GeneralRange<T> reverse;

  /** Returns the same range relative to the reversed comparator. */
  GeneralRange<T> reverse() {
    GeneralRange<T> result = reverse;
    if (result == null) {
      result =
          new GeneralRange<>(
              reverseComparator(comparator),

SequencedCollection<String> sequenced = CollectionsUtil.newLinkedHashSet();
String first = CollectionsUtil.getFirst(sequenced);
String last = CollectionsUtil.getLast(sequenced);
SequencedCollection<String> reversed = CollectionsUtil.reversed(sequenced);

// Specialized collections
LruHashMap<String, Object> lruCache = new LruHashMap<>(100); // LRU cache with max 100 entries
CaseInsensitiveMap<String> configMap = new CaseInsensitiveMap<>();
```