}
        ImmutableMultimap<String, HashCode> rootHashes = readRootHashes(decoder);
        HashCode strategyConfigurationHash = hashCodeSerializer.read(decoder);
        return new SerializableFileCollectionFingerprint(fingerprints, rootHashes, strategyConfigurationHash);
    }

    private ImmutableMultimap<String, HashCode> readRootHashes(Decoder decoder) throws IOException {

            return false;
        }
        return executionTime.equals(that.executionTime);
    }

    @Override
    public int hashCode() {
        int result = buildInvocationId.hashCode();
        result = 31 * result + buildCacheKey.hashCode();
        result = 31 * result + executionTime.hashCode();
        return result;
    }

    @Override
    public String toString() {
        return "OriginMetadata{"

    public val occurrencesRange: EventOccurrencesRange get() = withValidityAssertion { backingOccurrencesRange }

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

        private final ExcludeSpec right;
        private final int hashCode;

        // Optimizes comparisons by making sure that the 2 elements of
        // the pair are "sorted" by hashcode ascending
        private static ExcludePair of(ExcludeSpec left, ExcludeSpec right) {
            if (left.hashCode() > right.hashCode()) {
                return new ExcludePair(right, left);
            }

    }

    override fun hashCode(): Int {
        var result = templateId.hashCode()
        result = 31 * result + sourceHash.hashCode()
        parentClassLoader.get()?.let { loader ->
            result = 31 * result + loader.hashCode()
        }
        accessorsClassPathHash?.let { classPathHash ->
            result = 31 * result + classPathHash.hashCode()
        }
        classPathHash?.let { classPathHash ->

    static class FileInfo {
        private final HashCode hash;
        private final long timestamp;
        private final long length;

        public FileInfo(HashCode hash, long length, long timestamp) {
            this.hash = hash;
            this.length = length;
            this.timestamp = timestamp;
        }

        public HashCode getHash() {
            return hash;
        }
    }

    private final String identifier;
    private final FileSystemSnapshot roots;
    private final ImmutableMultimap<String, HashCode> rootHashes;
    private final HashCode strategyConfigurationHash;
    private HashCode hash;

    public static CurrentFileCollectionFingerprint from(FileSystemSnapshot roots, FingerprintingStrategy strategy, @Nullable  FileCollectionFingerprint candidate) {

        assert createCompositeSpec(spec1).hashCode() == createCompositeSpec(spec1).hashCode();
        assert createCompositeSpec(spec1).hashCode() != createCompositeSpec(spec2).hashCode();

        assert createCompositeSpec(spec1, spec2).hashCode() == createCompositeSpec(spec1, spec2).hashCode();
        assert createCompositeSpec(spec2, spec1).hashCode() == createCompositeSpec(spec2, spec1).hashCode();

        expect:
        HashCode.fromString("12345678").toZeroPaddedString(8) == "12345678"
        HashCode.fromString("12345678").toZeroPaddedString(7) == "12345678"
        HashCode.fromString("12345678").toZeroPaddedString(0) == "12345678"
        HashCode.fromString("12345678").toZeroPaddedString(9) == "012345678"
        HashCode.fromString("12345678").toZeroPaddedString(16) == "0000000012345678"

    }

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

    private int computeHashCode() {
        int result = owner.hashCode();
        result = 31 * result + displayName.hashCode();
        result = 31 * result + attributes.hashCode();
        result = 31 * result + capabilities.hashCode();
        if (externalVariant != null) {