*/
  public static <A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      Function<A, C> compose(Function<B, C> g, Function<A, ? extends B> f) {
    return new FunctionComposition<>(g, f);
  }

  private static final class FunctionComposition<
          A extends @Nullable Object, B extends @Nullable Object, C extends @Nullable Object>
      implements Function<A, C>, Serializable {

   */
  public static <T extends @Nullable Object> Predicate<T> alwaysFalse() {
    return ObjectPredicate.ALWAYS_FALSE.withNarrowedType();
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the object reference being tested is
   * null.
   *
   * <p><b>Discouraged:</b> Prefer using either {@code x -> x == null} or {@code Objects::isNull},

public final class CollectorTester<
    T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object> {
  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using {@link Object#equals}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>

    Ordering<Number> unusedF = numbers.compound(objects).compound(objects); // bad IDEA
    Ordering<Number> unusedG = objects.compound(numbers).compound(objects);
    Ordering<Number> unusedH = objects.compound(objects).compound(numbers);

    Ordering<Number> unusedI = numbers.compound(objects.compound(objects));
    Ordering<Number> unusedJ = objects.compound(numbers.compound(objects)); // bad IDEA

    Ordering<Number> unusedF = numbers.compound(objects).compound(objects); // bad IDEA
    Ordering<Number> unusedG = objects.compound(numbers).compound(objects);
    Ordering<Number> unusedH = objects.compound(objects).compound(numbers);

    Ordering<Number> unusedI = numbers.compound(objects.compound(objects));
    Ordering<Number> unusedJ = objects.compound(numbers.compound(objects)); // bad IDEA

  }

  @Override
  public boolean equals(@Nullable Object object) {
    return object == this || delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**
   * A sensible definition of {@link #putAll(Map)} in terms of {@link #put(Object, Object)}. If you
   * override {@link #put(Object, Object)}, you may wish to override {@link #putAll(Map)} to forward

   * @throws IllegalArgumentException if {@code expectedSize} is negative
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactHashMap<K, V> createWithExpectedSize(int expectedSize) {
    return new CompactHashMap<>(expectedSize);
  }

  private static final Object NOT_FOUND = new Object();

  /**
   * Maximum allowed false positive probability of detecting a hash flooding attack given random

					}
					prevPrefix = currPrefix
					objects = append(objects, ObjectInfo{
						IsDir:  true,
						Bucket: bucket,
						Name:   currPrefix,
					})
					continue
				}
			}

			fi, err := entry.fileInfo(bucket)
			if err == nil && fi.VersionPurgeStatus().Empty() {
				versioned := vcfg != nil && vcfg.Versioned(entry.name)
				objects = append(objects, fi.ToObjectInfo(bucket, entry.name, versioned))
			}

        }

        @Override
        public Object[] toArray() {
          /*
           * standardToArray returns `@Nullable Object[]` rather than `Object[]` but only because it
           * can be used with collections that may contain null. This collection is a collection of
           * non-null Entry objects (Entry objects that might contain null values but are not

   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Supplier<T> compose(
      Function<? super F, T> function, Supplier<F> supplier) {
    return new SupplierComposition<>(function, supplier);
  }

  private static final class SupplierComposition<
          F extends @Nullable Object, T extends @Nullable Object>
      implements Supplier<T>, Serializable {