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

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

import gradlebuild.docs.DocGenerationException;

public class ClassDocGenerationException extends DocGenerationException {
    public ClassDocGenerationException(String message, Throwable throwable) {
        super(message, throwable);
    }

      String message, Set<Feature<?>> conflicts, Object source) {
    super(message);
    this.conflicts = conflicts;
    this.source = source;
  }

  public Set<Feature<?>> getConflicts() {
    return conflicts;
  }

  public Object getSource() {
    return source;
  }

  @Override
  public String getMessage() {
    return super.getMessage() + " (source: " + source + ")";
  }

      return String.valueOf(hash);
    }
  }

  static class SlowElement extends Element {
    SlowElement(int hash) {
      super(hash);
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return slowItDown() != 1 && super.equals(obj);
    }

    @Override
    public int hashCode() {
      return slowItDown() + hash;
    }

    @Override

    implements SortedMultiset<E> {
  abstract SortedMultiset<E> forwardMultiset();

  @LazyInit private transient @Nullable Comparator<? super E> comparator;

  @Override
  public Comparator<? super E> comparator() {
    Comparator<? super E> result = comparator;
    if (result == null) {
      result = Ordering.from(forwardMultiset().comparator()).reverse();
      comparator = result;
    }

        super("ECL0041", asArray(targetClass.getName(), cause), cause);
        this.targetClass = targetClass;
    }

    @Override
    public synchronized InstantiationRuntimeException initCause(final Throwable cause) {
        return (InstantiationRuntimeException) super.initCause(cause);
    }

    /**
     * Returns the target class.
     *

        super(pomArtifact, artifacts, resolutionRepositories);
    }

    public ResolutionGroup(
            Artifact pomArtifact,
            Artifact relocatedArtifact,
            Set<Artifact> artifacts,
            Map<String, Artifact> managedVersions,
            List<ArtifactRepository> resolutionRepositories) {

    }
  }

  public void testComposeOfFunctionsIsAssociative() {
    Map<Float, String> m = ImmutableMap.of(4.0f, "A", 3.0f, "B", 2.0f, "C", 1.0f, "D");
    Function<? super Integer, Boolean> h = Functions.constant(Boolean.TRUE);
    Function<? super String, Integer> g = new HashCodeFunction();
    Function<Float, String> f = Functions.forMap(m, "F");

    Function<Float, Boolean> c1 = Functions.compose(Functions.compose(h, g), f);

    public CommandExecutionException(final String message) {
        super(message);
    }

    /**
     * Constructor with error message and cause.
     * @param message The error message describing the command execution failure.
     * @param e The cause of the exception.
     */
    public CommandExecutionException(final String message, final Throwable e) {
        super(message, e);
    }

     */
    public ThemeException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new ThemeException with the specified message.
     *
     * @param message the exception message
     */
    public ThemeException(final String message) {
        super(message);
    }