public fun negated(): KaContractIsInstancePredicateExpression = KaContractIsInstancePredicateExpression(argument, type, !isNegated)

    override fun hashCode(): Int = Objects.hashCode(backingArgument, backingType, backingIsNegated)
    override fun equals(other: Any?): Boolean {
        return this === other ||
                other is KaContractIsInstancePredicateExpression &&

    for (E element : getOrderedElements()) {
      expectedHashCode = 31 * expectedHashCode + ((element == null) ? 0 : element.hashCode());
    }
    assertEquals(
        "A List's hashCode() should be computed from those of its elements.",
        expectedHashCode,
        getList().hashCode());
  }

  /**
   * Returns the {@link Method} instance for {@link #testHashCode()} so that list tests on

        buildCacheKeys.clear()
        rawBuildCacheKeys.each {
            buildCacheKeys[it.key] = HashCode.fromBytes(it.value as byte[])
        }
    }

    HashCode buildCacheKey(String path) {
        buildCacheKeys[path]
    }

        return Objects.equal(keySerializer, rhs.keySerializer)
            && Objects.equal(valueSerializer, rhs.valueSerializer);
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(super.hashCode(), keySerializer, valueSerializer);
    }

    static class File {
        final String name
        final String url
        final long size
        final HashCode sha1
        final HashCode sha256
        final HashCode sha512
        final HashCode md5

        File(String name, String url, long size, HashCode sha1, HashCode md5, HashCode sha256, HashCode sha512) {
            this.name = name
            this.url = url
            this.size = size

        @Override
        public boolean equals(Object obj) {
            return obj != null && obj.getClass().equals(Spec.class);
        }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

  /**
   * A sensible definition of {@link #hashCode()} in terms of {@link #getKey()} and {@link
   * #getValue()}. If you override either of these methods, you may wish to override {@link
   * #hashCode()} to forward to this implementation.
   *
   * @since 7.0
   */
  protected int standardHashCode() {
    K k = getKey();
    V v = getValue();
    return ((k == null) ? 0 : k.hashCode()) ^ ((v == null) ? 0 : v.hashCode());
  }

            return consumerSchema.equals(that.consumerSchema) && producerSchema.equals(that.producerSchema);
        }

        @Override
        public int hashCode() {
            return Objects.hashCode(consumerSchema, producerSchema);
        }
    }

    /**
     * A cache entry key, leveraging _identity_ as the key, because we do interning.
     * This is a performance optimization.

        }
        if (!message.equals(that.message)) {
            return false;
        }

        return true;
    }

    @Override
    public int hashCode() {
        int result = destination.hashCode();
        result = 31 * result + message.hashCode();
        return result;
    }

        }

        EnumValueSnapshot other = (EnumValueSnapshot) obj;
        return className.equals(other.className) && name.equals(other.name);
    }

    @Override
    public int hashCode() {
        return className.hashCode() ^ name.hashCode();
    }

    @Override
    public String toString() {
        return className + "." + name;
    }