return endOfData();
            }
          };
        }
      };
    }

    @Override
    public boolean equals(@Nullable Object o) {
      if (o instanceof RangeMap) {
        RangeMap<?, ?> rangeMap = (RangeMap<?, ?>) o;
        return asMapOfRanges().equals(rangeMap.asMapOfRanges());
      }
      return false;
    }

    @Override
    public int hashCode() {

        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Key key = (Key) o;
            return groupId.equals(key.groupId)
                    && artifactId.equals(key.artifactId)

    public V getValue() {
      return value;
    }

    @Override
    public boolean equals(@Nullable Object object) {
      // Cannot use key and value equivalence
      if (object instanceof Entry) {
        Entry<?, ?> that = (Entry<?, ?>) object;
        return key.equals(that.getKey()) && value.equals(that.getValue());
      }
      return false;
    }

    @Override
    public int hashCode() {

            }

            @Override
            public boolean equals(Object o) {
                return o instanceof DefaultToolchainsBuilderRequest that
                        && Objects.equals(installationToolchainsSource, that.installationToolchainsSource)
                        && Objects.equals(userToolchainsSource, that.userToolchainsSource);
            }

            @Override

    }

    @Override
    public void omitForNearer(Artifact omitted, Artifact kept) {
        String omittedVersion = omitted.getVersion();
        String keptVersion = kept.getVersion();

        if (!Objects.equals(omittedVersion, keptVersion)) {
            logger.debug(indent + omitted + " (removed - nearer found: " + keptVersion + ")");
        }
    }

    @Override
    public void omitForCycle(Artifact omitted) {

    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        final StemmerOverrideItem other = (StemmerOverrideItem) obj;
        if (!Objects.equals(input, other.input) || !Objects.equals(output, other.output)) {
            return false;

            }

            @Override
            public boolean equals(Object o) {
                return o instanceof DefaultArtifactDeployerRequest that
                        && retryFailedDeploymentCount == that.retryFailedDeploymentCount
                        && Objects.equals(repository, that.repository)
                        && Objects.equals(artifacts, that.artifacts);
            }

            @Override

    assertEquals(Sets.newTreeSet(asList("a", "b", "c")), set);
    assertFalse(set.equals(Sets.newTreeSet(asList("a", "b", "d"))));
    assertFalse(Sets.newTreeSet(asList("a", "b", "d")).equals(set));
    assertFalse(set.equals(newHashSet(4, 5, 6)));
    assertFalse(newHashSet(4, 5, 6).equals(set));
  }

  public void testEquals_bothExplicitOrdering() {
    SortedSet<String> set = of("in", "the", "a");

    return delegate().elementSet();
  }

  @Override
  public Set<Entry<E>> entrySet() {
    return delegate().entrySet();
  }

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

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

  @CanIgnoreReturnValue
  @Override

        buf.append(")");
        return buf.toString();
    }

    /**
     * Returns whether the method is the {@literal equals(Object)} method.
     *
     * @param method
     *            The method. Cannot be {@literal null}
     * @return {@literal true} if the method is {@literal equals(Object)}
     */
    public static boolean isEqualsMethod(final Method method) {
        assertArgumentNotNull("method", method);