private final HashCode normalizedContentHash;
    private final String normalizedPath;

    public DefaultFileSystemLocationFingerprint(String normalizedPath, FileType type, HashCode contentHash) {
        this.normalizedContentHash = hashForType(type, contentHash);
        this.normalizedPath = normalizedPath;
    }

    private static HashCode hashForType(FileType fileType, HashCode hash) {
        switch (fileType) {

                def originalClassName = type.getMethod('getOriginalClassName').invoke(o)
                def contentHash = type.getMethod('getContentHash').invoke(o)
                println "\${title} class name: \${originalClassName} (remapped: \${type.name})"
                println "\${title} class hash: \${contentHash}"
            }
        """
    }

            return locationCache.computeIfAbsent(file,
                location -> fileSystemAccess.readRegularFileContentHash(location.getAbsolutePath())
                    .map(contentHash -> contentCache.get(contentHash, key -> calculator.calculate(location, true))
                ).orElseGet(
                    () -> calculator.calculate(location, false)
                ));
        }

            switch (type) {
                case REGULAR_FILE:
                    HashCode contentHash = readHashCode(decoder);
                    long lastModified = decoder.readSmallLong();
                    long length = decoder.readSmallLong();
                    stack.add(new RegularFileSnapshot(internedAbsolutePath, internedName, contentHash, DefaultFileMetadata.file(lastModified, length, accessType)));
                    break;

	_ *encryptionconfig.EncryptionConfiguration,
	configChanged bool,
	_ error,
) {
	contentHash, err := d.getEncryptionConfigHash(ctx, d.filePath)
	if err != nil {
		return nil, false, err
	}

	// check if encryptionConfig is different from the current. Do nothing if they are the same.
	if contentHash == d.lastLoadedEncryptionConfigHash {