* sorted multiset, either directly, or through its {@code elementSet} or {@code entrySet} views. In
 * all cases, this implementation uses {@link Comparable#compareTo} or {@link Comparator#compare}
 * instead of {@link Object#equals} to determine equivalence of instances.
 *
 * <p><b>Warning:</b> The comparison must be <i>consistent with equals</i> as explained by the

 * sorted multiset, either directly, or through its {@code elementSet} or {@code entrySet} views. In
 * all cases, this implementation uses {@link Comparable#compareTo} or {@link Comparator#compare}
 * instead of {@link Object#equals} to determine equivalence of instances.
 *
 * <p><b>Warning:</b> The comparison must be <i>consistent with equals</i> as explained by the

        "run again after ${formatDuration(executeNanoTime - now)}"
      } else {
        "scheduled after ${formatDuration(executeNanoTime - now)}"
      }
    }

    // Insert in chronological order. Always compare deltas because nanoTime() is permitted to wrap.
    var insertAt = futureTasks.indexOfFirst { it.nextExecuteNanoTime - now > delayNanos }
    if (insertAt == -1) insertAt = futureTasks.size
    futureTasks.add(insertAt, task)

    }

    /**
     * Compares this CharMappingItem with another object for equality.
     * Two CharMappingItem objects are equal if they have the same inputs and output.
     * Note: inputs arrays are sorted in the constructor, so no sorting is needed here.
     *
     * @param obj the object to compare with
     * @return true if the objects are equal, false otherwise
     */

      return new Ordering<Entry<AnEnum, String>>() {

        @Override
        public int compare(Entry<AnEnum, String> left, Entry<AnEnum, String> right) {
          return left.getKey().compareTo(right.getKey());
        }
      }.sortedCopy(insertionOrder);
    }
  }

  public static class ImmutableMapValuesAsSingletonSetGenerator

  }

  @CanIgnoreReturnValue
  private <T> T checkValid(T t) {
    // a ClassCastException is what's supposed to happen!
    @SuppressWarnings("unchecked")
    E e = (E) t;
    int unused = comparator().compare(e, e);
    return t;
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return delegate.equals(obj);
  }

  @Override
  public int hashCode() {

     * inclusive ranges" and "Cuts."
     */
    if (lowerBound.compareTo(otherRange.upperBound) < 0
        && otherRange.lowerBound.compareTo(upperBound) < 0) {
      throw new IllegalArgumentException(
          "Ranges have a nonempty intersection: " + this + ", " + otherRange);
    }

    boolean isThisFirst = this.lowerBound.compareTo(otherRange.lowerBound) < 0;
    Range<C> firstRange = isThisFirst ? this : otherRange;

  }

  /**
   * Compares this unsigned integer to another unsigned integer. Returns {@code 0} if they are
   * equal, a negative number if {@code this < other}, and a positive number if {@code this >
   * other}.
   */
  @Override
  public int compareTo(UnsignedInteger other) {
    checkNotNull(other);
    return compare(value, other.value);
  }

  @Override

     * inclusive ranges" and "Cuts."
     */
    if (lowerBound.compareTo(otherRange.upperBound) < 0
        && otherRange.lowerBound.compareTo(upperBound) < 0) {
      throw new IllegalArgumentException(
          "Ranges have a nonempty intersection: " + this + ", " + otherRange);
    }

    boolean isThisFirst = this.lowerBound.compareTo(otherRange.lowerBound) < 0;
    Range<C> firstRange = isThisFirst ? this : otherRange;

    }
  }

  @Nullable E higher(E e) {
    checkNotNull(e);
    Iterator<E> iterator = tailSet(e).iterator();
    while (iterator.hasNext()) {
      E higher = iterator.next();
      if (comparator().compare(e, higher) < 0) {
        return higher;
      }
    }
    return null;
  }

  public @Nullable E ceiling(E e) {
    ImmutableSortedSet<E> set = tailSet(e, true);