}
        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 {

    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 &&

        }

        @Override
        public void putHash(HashCode hashCode) {
            hashCode.appendToHasher(this);
        }

        @Override
        public HashCode hash() {
            byte[] bytes = getDigest().digest();
            digest = null;
            return HashCode.fromBytes(bytes, SAFE_TO_REUSE_BYTES);
        }
    }

    }

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

  static class SameIntegerInstance {
    private final Integer i;

    public SameIntegerInstance(Integer i) {
      this.i = checkNotNull(i);
    }

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

    @Override

import org.gradle.internal.hash.HashCode;
import org.gradle.internal.hash.Hasher;

public class DefaultFileSystemLocationFingerprint implements FileSystemLocationFingerprint {
    private final HashCode normalizedContentHash;
    private final String normalizedPath;

    public DefaultFileSystemLocationFingerprint(String normalizedPath, FileType type, HashCode contentHash) {

        this.timestamp = timestamp;
        this.hashCode = super.hashCode() + timestamp.hashCode();
    }

    @Override
    public boolean equals(Object o) {
        return super.equals(o) && ((MavenUniqueSnapshotComponentIdentifier) o).timestamp.equals(timestamp);
    }

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

    @Override
    public String getDisplayName() {

            writeClassPath(scope.exportClassPath)
        }
    }

    private
    fun WriteContext.writeHashCode(hashCode: HashCode?) {
        if (hashCode == null) {
            writeBoolean(false)
        } else {
            writeBoolean(true)
            writeBinary(hashCode.toByteArray())
        }
    }

        return true
    }

    override fun hashCode(): Int {
        var result = backingSymbol.hashCode()
        result = 31 * result + backingReturnType.hashCode()
        result = 31 * result + (backingReceiverType?.hashCode() ?: 0)
        result = 31 * result + backingValueParameters.hashCode()
        return result
    }

import org.gradle.internal.hash.HashCode;

import java.io.IOException;

@Immutable
public class HashCodeSerializer extends AbstractSerializer<HashCode> {
    @Override
    public HashCode read(Decoder decoder) throws IOException {
        byte hashSize = decoder.readByte();
        byte[] hash = new byte[hashSize];
        decoder.readBytes(hash);
        return HashCode.fromBytes(hash);
    }

    @Override

    public val right: KaContractBooleanExpression get() = withValidityAssertion { backingRight }
    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 &&