}

    private boolean equals(Dependency d1, Dependency d2) {
        return Objects.equals(d1.getGroupId(), d2.getGroupId())
                && Objects.equals(d1.getArtifactId(), d2.getArtifactId())
                && Objects.equals(d1.getVersion(), d2.getVersion())
                && Objects.equals(d1.getType(), d2.getType())
                && Objects.equals(d1.getClassifier(), d2.getClassifier())

    override fun hashCode(): Int = Objects.hashCode(backingValueParameterReference, backingOccurrencesRange)
    override fun equals(other: Any?): Boolean {
        return this === other ||
                other is KaContractCallsInPlaceContractEffectDeclaration &&
                other.backingValueParameterReference == backingValueParameterReference &&

                if (JavaPathType.CLASSES.equals(type)) {
                    classes = true;
                } else if (JavaPathType.MODULES.equals(type)) {
                    modules = true;
                } else if (JavaPathType.PROCESSOR_CLASSES.equals(type)) {
                    processorClasses = true;
                } else if (JavaPathType.PROCESSOR_MODULES.equals(type)) {
                    processorModules = true;

    public val operation: KaLogicOperation get() = withValidityAssertion { backingOperation }

    override fun hashCode(): Int = Objects.hashCode(backingLeft, backingRight, backingOperation)
    override fun equals(other: Any?): Boolean {
        return this === other ||
                other is KaContractBinaryLogicExpression &&
                other.backingLeft == backingLeft &&
                other.backingRight == backingRight &&

        KaFirVariableLikeSubstitutorBasedSignature(token, firSymbol, firSymbolBuilder, chainedSubstitutor)
    }

    override fun equals(other: Any?): Boolean {
        if (!super.equals(other)) return false

        other as KaFirVariableLikeSubstitutorBasedSignature<*>
        return coneSubstitutor == other.coneSubstitutor
    }

    public enum class KaContractConstantType {
        NULL, TRUE, FALSE;
    }

    public val constantType: KaContractConstantType get() = withValidityAssertion { backingConstantType }

    override fun equals(other: Any?): Boolean {
        return this === other || other is KaContractConstantValue && other.backingConstantType == backingConstantType
    }

    override fun hashCode(): Int = backingConstantType.hashCode()
}

                return all.keySet().stream()
                        .filter(id -> !Lifecycle.CLEAN.equals(id)
                                && !Lifecycle.DEFAULT.equals(id)
                                && !Lifecycle.SITE.equals(id)
                                && !Lifecycle.WRAPPER.equals(id))
                        .map(id -> wrap(all.get(id)))
                        .collect(Collectors.toList());

    public val parameterSymbol: KaParameterSymbol get() = withValidityAssertion { backingParameterSymbol }
    override fun hashCode(): Int = backingParameterSymbol.hashCode()
    override fun equals(other: Any?): Boolean {
        return this === other || other is KaContractBooleanValueParameterExpression && other.backingParameterSymbol == backingParameterSymbol
    }
}

) : KaLifetimeOwner {
    public val isStable: Boolean get() = withValidityAssertion { backingIsStable }
    public val smartCastType: KaType get() = withValidityAssertion { backingSmartCastType }

    override fun equals(other: Any?): Boolean {
        return this === other ||
                other is KaSmartCastInfo &&
                other.backingSmartCastType == backingSmartCastType &&
                other.backingIsStable == backingIsStable

        KaFirFunctionLikeSubstitutorBasedSignature(token, firSymbol, firSymbolBuilder, chainedSubstitutor)
    }

    override fun equals(other: Any?): Boolean {
        if (!super.equals(other)) return false

        other as KaFirFunctionLikeSubstitutorBasedSignature<*>
        return coneSubstitutor == other.coneSubstitutor
    }