ExplicitOrdering<?> that = (ExplicitOrdering<?>) object;
      return this.rankMap.equals(that.rankMap);
    }
    return false;
  }

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

  @Override
  public String toString() {
    return "Ordering.explicit(" + rankMap.keySet() + ")";
  }

  @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

        return Optional.empty();
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type, String name) {
        return Optional.empty();
    }

    @Override
    public <T> List<T> lookupList(Class<T> type) {
        return List.of();
    }

    @Override
    public <T> Map<String, T> lookupMap(Class<T> type) {
        return Map.of();
    }

   */
  Map<Range<K>, V> asMapOfRanges();

  /**
   * Returns a view of this range map as an unmodifiable {@code Map<Range<K>, V>}. Modifications to
   * this range map are guaranteed to read through to the returned {@code Map}.
   *
   * <p>The returned {@code Map} iterates over entries in descending order of the bounds of the
   * {@code Range} entries.
   *

      @Override
      protected Iterator<E> newTargetIterator() {
        return getSubjectGenerator().create(e0(), e1(), e1(), e2()).iterator();
      }
    }.test();
  }

  /**
   * Returns {@link Method} instances for the tests that assume multisets support duplicates so that
   * the test of {@code Multisets.forSet()} can suppress them.
   */

         * @return List
         */
        List<?> listOfWildcard();
    }

    /**
     *
     */
    public interface SetType {

        /**
         * @return Set
         */
        Set<String> setOfString();

        /**
         * @return Set
         */
        Set<Class<?>> setOfClass();

        /**
         * @return Set
         */

            result += scope.hashCode();
        }
        return result;
    }

    @Override
    public boolean equals(final Object obj) {
        Name n;

        if (!(obj instanceof Name)) {
            return false;
        }
        n = (Name) obj;
        if (scope == null && n.scope == null) {
            return name.equals(n.name) && hexCode == n.hexCode;
        }

        this.data = data;
    }

    /**
     * Get the DFS referral data associated with this referral
     *
     * @return the DFS referral data
     */
    public DfsReferralData getData() {
        return this.data;
    }

    @Override
    public String toString() {
        return this.data.toString();
    }

      int j = i & ARRAY_MASK;
      tmp += LongMath.pow(positive[j], exponents[j]);
    }
    return tmp;
  }

  @Benchmark
  int mod(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += LongMath.mod(longs[j], positive[j]);
    }
    return tmp;
  }

  @Benchmark
  int gCD(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {

     */
    @Override
    public boolean isOpen() {
        return this.handle.isOpen();
    }

    @Override
    protected synchronized SmbTreeHandleImpl ensureTreeConnected() throws CIFSException {
        return this.handle.ensureTreeConnected();
    }

    @Override
    protected synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        return this.handle.ensureOpen();
    }

    /**

        artifact.setFile(artifactFile);

        return artifact;
    }

    @Override
    public String getId() {
        return localRepository.getId();
    }

    @Override
    public String pathOfLocalRepositoryMetadata(ArtifactMetadata metadata, ArtifactRepository repository) {
        return localRepository.pathOfLocalRepositoryMetadata(metadata, repository);
    }

    @Override