include/vulkan/vulkan_hash.hpp

// Copyright 2015-2022 The Khronos Group Inc.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
//

// This header is generated from the Khronos Vulkan XML API Registry.

#ifndef VULKAN_HASH_HPP
#define VULKAN_HASH_HPP

#include <vulkan/vulkan.hpp>

namespace std {
//=======================================
//=== HASH structures for Flags types ===
//=======================================

template<typename BitType>
struct hash<VULKAN_HPP_NAMESPACE::Flags<BitType>>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Flags<BitType> const &flags) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<typename std::underlying_type<BitType>::type>{}(static_cast<typename std::underlying_type<BitType>::type>(flags));
	}
};

//===================================
//=== HASH structures for handles ===
//===================================

//=== VK_VERSION_1_0 ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::Instance>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Instance const &instance) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkInstance>{}(static_cast<VkInstance>(instance));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevice const &physicalDevice) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkPhysicalDevice>{}(static_cast<VkPhysicalDevice>(physicalDevice));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Device>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Device const &device) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDevice>{}(static_cast<VkDevice>(device));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Queue>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Queue const &queue) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkQueue>{}(static_cast<VkQueue>(queue));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceMemory>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceMemory const &deviceMemory) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDeviceMemory>{}(static_cast<VkDeviceMemory>(deviceMemory));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Fence>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Fence const &fence) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkFence>{}(static_cast<VkFence>(fence));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Semaphore>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Semaphore const &semaphore) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkSemaphore>{}(static_cast<VkSemaphore>(semaphore));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Event>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Event const &event) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkEvent>{}(static_cast<VkEvent>(event));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueryPool>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::QueryPool const &queryPool) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkQueryPool>{}(static_cast<VkQueryPool>(queryPool));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Buffer>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Buffer const &buffer) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkBuffer>{}(static_cast<VkBuffer>(buffer));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferView>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferView const &bufferView) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkBufferView>{}(static_cast<VkBufferView>(bufferView));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Image>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Image const &image) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkImage>{}(static_cast<VkImage>(image));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageView>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageView const &imageView) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkImageView>{}(static_cast<VkImageView>(imageView));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ShaderModule>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ShaderModule const &shaderModule) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkShaderModule>{}(static_cast<VkShaderModule>(shaderModule));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCache>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCache const &pipelineCache) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkPipelineCache>{}(static_cast<VkPipelineCache>(pipelineCache));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Pipeline>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Pipeline const &pipeline) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkPipeline>{}(static_cast<VkPipeline>(pipeline));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineLayout>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineLayout const &pipelineLayout) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkPipelineLayout>{}(static_cast<VkPipelineLayout>(pipelineLayout));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Sampler>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Sampler const &sampler) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkSampler>{}(static_cast<VkSampler>(sampler));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorPool>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorPool const &descriptorPool) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDescriptorPool>{}(static_cast<VkDescriptorPool>(descriptorPool));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSet>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSet const &descriptorSet) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDescriptorSet>{}(static_cast<VkDescriptorSet>(descriptorSet));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayout>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetLayout const &descriptorSetLayout) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDescriptorSetLayout>{}(static_cast<VkDescriptorSetLayout>(descriptorSetLayout));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Framebuffer>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Framebuffer const &framebuffer) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkFramebuffer>{}(static_cast<VkFramebuffer>(framebuffer));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPass>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderPass const &renderPass) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkRenderPass>{}(static_cast<VkRenderPass>(renderPass));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandPool>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandPool const &commandPool) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkCommandPool>{}(static_cast<VkCommandPool>(commandPool));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBuffer>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandBuffer const &commandBuffer) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkCommandBuffer>{}(static_cast<VkCommandBuffer>(commandBuffer));
	}
};

//=== VK_VERSION_1_1 ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const &samplerYcbcrConversion) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkSamplerYcbcrConversion>{}(static_cast<VkSamplerYcbcrConversion>(samplerYcbcrConversion));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const &descriptorUpdateTemplate) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDescriptorUpdateTemplate>{}(static_cast<VkDescriptorUpdateTemplate>(descriptorUpdateTemplate));
	}
};

//=== VK_VERSION_1_3 ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlot>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PrivateDataSlot const &privateDataSlot) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkPrivateDataSlot>{}(static_cast<VkPrivateDataSlot>(privateDataSlot));
	}
};

//=== VK_KHR_surface ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceKHR const &surfaceKHR) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkSurfaceKHR>{}(static_cast<VkSurfaceKHR>(surfaceKHR));
	}
};

//=== VK_KHR_swapchain ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SwapchainKHR const &swapchainKHR) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkSwapchainKHR>{}(static_cast<VkSwapchainKHR>(swapchainKHR));
	}
};

//=== VK_KHR_display ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayKHR const &displayKHR) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDisplayKHR>{}(static_cast<VkDisplayKHR>(displayKHR));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayModeKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayModeKHR const &displayModeKHR) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDisplayModeKHR>{}(static_cast<VkDisplayModeKHR>(displayModeKHR));
	}
};

//=== VK_EXT_debug_report ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const &debugReportCallbackEXT) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDebugReportCallbackEXT>{}(static_cast<VkDebugReportCallbackEXT>(debugReportCallbackEXT));
	}
};

#if defined(VK_ENABLE_BETA_EXTENSIONS)
//=== VK_KHR_video_queue ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoSessionKHR const &videoSessionKHR) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkVideoSessionKHR>{}(static_cast<VkVideoSessionKHR>(videoSessionKHR));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const &videoSessionParametersKHR) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkVideoSessionParametersKHR>{}(static_cast<VkVideoSessionParametersKHR>(videoSessionParametersKHR));
	}
};
#endif /*VK_ENABLE_BETA_EXTENSIONS*/

//=== VK_NVX_binary_import ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::CuModuleNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CuModuleNVX const &cuModuleNVX) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkCuModuleNVX>{}(static_cast<VkCuModuleNVX>(cuModuleNVX));
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CuFunctionNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CuFunctionNVX const &cuFunctionNVX) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkCuFunctionNVX>{}(static_cast<VkCuFunctionNVX>(cuFunctionNVX));
	}
};

//=== VK_EXT_debug_utils ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const &debugUtilsMessengerEXT) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDebugUtilsMessengerEXT>{}(static_cast<VkDebugUtilsMessengerEXT>(debugUtilsMessengerEXT));
	}
};

//=== VK_KHR_acceleration_structure ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const &accelerationStructureKHR) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkAccelerationStructureKHR>{}(static_cast<VkAccelerationStructureKHR>(accelerationStructureKHR));
	}
};

//=== VK_EXT_validation_cache ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ValidationCacheEXT const &validationCacheEXT) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkValidationCacheEXT>{}(static_cast<VkValidationCacheEXT>(validationCacheEXT));
	}
};

//=== VK_NV_ray_tracing ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureNV const &accelerationStructureNV) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkAccelerationStructureNV>{}(static_cast<VkAccelerationStructureNV>(accelerationStructureNV));
	}
};

//=== VK_INTEL_performance_query ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const &performanceConfigurationINTEL) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkPerformanceConfigurationINTEL>{}(static_cast<VkPerformanceConfigurationINTEL>(performanceConfigurationINTEL));
	}
};

//=== VK_KHR_deferred_host_operations ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeferredOperationKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeferredOperationKHR const &deferredOperationKHR) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkDeferredOperationKHR>{}(static_cast<VkDeferredOperationKHR>(deferredOperationKHR));
	}
};

//=== VK_NV_device_generated_commands ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const &indirectCommandsLayoutNV) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkIndirectCommandsLayoutNV>{}(static_cast<VkIndirectCommandsLayoutNV>(indirectCommandsLayoutNV));
	}
};

#if defined(VK_USE_PLATFORM_FUCHSIA)
//=== VK_FUCHSIA_buffer_collection ===

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const &bufferCollectionFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		return std::hash<VkBufferCollectionFUCHSIA>{}(static_cast<VkBufferCollectionFUCHSIA>(bufferCollectionFUCHSIA));
	}
};
#endif /*VK_USE_PLATFORM_FUCHSIA*/

#if 14 <= VULKAN_HPP_CPP_VERSION
//======================================
//=== HASH structures for structures ===
//======================================

#	if !defined(VULKAN_HPP_HASH_COMBINE)
#		define VULKAN_HPP_HASH_COMBINE(seed, value) \
			seed ^= std::hash<std::decay<decltype(value)>::type>{}(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2)
#	endif

template<>
struct hash<VULKAN_HPP_NAMESPACE::AabbPositionsKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AabbPositionsKHR const &aabbPositionsKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, aabbPositionsKHR.minX);
		VULKAN_HPP_HASH_COMBINE(seed, aabbPositionsKHR.minY);
		VULKAN_HPP_HASH_COMBINE(seed, aabbPositionsKHR.minZ);
		VULKAN_HPP_HASH_COMBINE(seed, aabbPositionsKHR.maxX);
		VULKAN_HPP_HASH_COMBINE(seed, aabbPositionsKHR.maxY);
		VULKAN_HPP_HASH_COMBINE(seed, aabbPositionsKHR.maxZ);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const &accelerationStructureBuildRangeInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildRangeInfoKHR.primitiveCount);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildRangeInfoKHR.firstVertex);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildRangeInfoKHR.transformOffset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const &accelerationStructureBuildSizesInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildSizesInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildSizesInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const &accelerationStructureCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoKHR.createFlags);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoKHR.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoKHR.offset);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoKHR.size);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoKHR.type);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoKHR.deviceAddress);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GeometryTrianglesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const &geometryTrianglesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.vertexData);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.vertexOffset);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.vertexCount);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.vertexStride);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.vertexFormat);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.indexData);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.indexOffset);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.indexCount);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.indexType);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.transformData);
		VULKAN_HPP_HASH_COMBINE(seed, geometryTrianglesNV.transformOffset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GeometryAABBNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::GeometryAABBNV const &geometryAABBNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, geometryAABBNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, geometryAABBNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, geometryAABBNV.aabbData);
		VULKAN_HPP_HASH_COMBINE(seed, geometryAABBNV.numAABBs);
		VULKAN_HPP_HASH_COMBINE(seed, geometryAABBNV.stride);
		VULKAN_HPP_HASH_COMBINE(seed, geometryAABBNV.offset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GeometryDataNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::GeometryDataNV const &geometryDataNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, geometryDataNV.triangles);
		VULKAN_HPP_HASH_COMBINE(seed, geometryDataNV.aabbs);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GeometryNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::GeometryNV const &geometryNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, geometryNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, geometryNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, geometryNV.geometryType);
		VULKAN_HPP_HASH_COMBINE(seed, geometryNV.geometry);
		VULKAN_HPP_HASH_COMBINE(seed, geometryNV.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const &accelerationStructureInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInfoNV.type);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInfoNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInfoNV.instanceCount);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInfoNV.geometryCount);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInfoNV.pGeometries);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const &accelerationStructureCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoNV.compactedSize);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureCreateInfoNV.info);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const &accelerationStructureDeviceAddressInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureDeviceAddressInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureDeviceAddressInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::TransformMatrixKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::TransformMatrixKHR const &transformMatrixKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		for(size_t i = 0; i < 3; ++i)
		{
			for(size_t j = 0; j < 4; ++j)
			{
				VULKAN_HPP_HASH_COMBINE(seed, transformMatrixKHR.matrix[i][j]);
			}
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const &accelerationStructureInstanceKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInstanceKHR.transform);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInstanceKHR.instanceCustomIndex);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInstanceKHR.mask);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInstanceKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureInstanceKHR.accelerationStructureReference);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const &accelerationStructureMatrixMotionInstanceNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMatrixMotionInstanceNV.transformT0);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMatrixMotionInstanceNV.transformT1);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMatrixMotionInstanceNV.mask);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMatrixMotionInstanceNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const &accelerationStructureMemoryRequirementsInfoNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMemoryRequirementsInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMemoryRequirementsInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMemoryRequirementsInfoNV.type);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const &accelerationStructureMotionInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMotionInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMotionInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMotionInfoNV.maxInstances);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureMotionInfoNV.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SRTDataNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SRTDataNV const &sRTDataNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.sx);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.a);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.b);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.pvx);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.sy);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.c);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.pvy);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.sz);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.pvz);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.qx);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.qy);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.qz);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.qw);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.tx);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.ty);
		VULKAN_HPP_HASH_COMBINE(seed, sRTDataNV.tz);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const &accelerationStructureSRTMotionInstanceNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureSRTMotionInstanceNV.transformT0);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureSRTMotionInstanceNV.transformT1);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureSRTMotionInstanceNV.mask);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureSRTMotionInstanceNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const &accelerationStructureVersionInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureVersionInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureVersionInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, accelerationStructureVersionInfoKHR.pVersionData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const &acquireNextImageInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, acquireNextImageInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, acquireNextImageInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, acquireNextImageInfoKHR.swapchain);
		VULKAN_HPP_HASH_COMBINE(seed, acquireNextImageInfoKHR.timeout);
		VULKAN_HPP_HASH_COMBINE(seed, acquireNextImageInfoKHR.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, acquireNextImageInfoKHR.fence);
		VULKAN_HPP_HASH_COMBINE(seed, acquireNextImageInfoKHR.deviceMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const &acquireProfilingLockInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, acquireProfilingLockInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, acquireProfilingLockInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, acquireProfilingLockInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, acquireProfilingLockInfoKHR.timeout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AllocationCallbacks>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AllocationCallbacks const &allocationCallbacks) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, allocationCallbacks.pUserData);
		VULKAN_HPP_HASH_COMBINE(seed, allocationCallbacks.pfnAllocation);
		VULKAN_HPP_HASH_COMBINE(seed, allocationCallbacks.pfnReallocation);
		VULKAN_HPP_HASH_COMBINE(seed, allocationCallbacks.pfnFree);
		VULKAN_HPP_HASH_COMBINE(seed, allocationCallbacks.pfnInternalAllocation);
		VULKAN_HPP_HASH_COMBINE(seed, allocationCallbacks.pfnInternalFree);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ComponentMapping>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ComponentMapping const &componentMapping) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, componentMapping.r);
		VULKAN_HPP_HASH_COMBINE(seed, componentMapping.g);
		VULKAN_HPP_HASH_COMBINE(seed, componentMapping.b);
		VULKAN_HPP_HASH_COMBINE(seed, componentMapping.a);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const &androidHardwareBufferFormatProperties2ANDROID) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.sType);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.format);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const &androidHardwareBufferFormatPropertiesANDROID) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.sType);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.format);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const &androidHardwareBufferPropertiesANDROID) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferPropertiesANDROID.sType);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferPropertiesANDROID.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferPropertiesANDROID.allocationSize);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const &androidHardwareBufferUsageANDROID) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferUsageANDROID.sType);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferUsageANDROID.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const &androidSurfaceCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, androidSurfaceCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, androidSurfaceCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, androidSurfaceCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, androidSurfaceCreateInfoKHR.window);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ApplicationInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ApplicationInfo const &applicationInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, applicationInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, applicationInfo.pNext);
		for(const char *p = applicationInfo.pApplicationName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		VULKAN_HPP_HASH_COMBINE(seed, applicationInfo.applicationVersion);
		for(const char *p = applicationInfo.pEngineName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		VULKAN_HPP_HASH_COMBINE(seed, applicationInfo.engineVersion);
		VULKAN_HPP_HASH_COMBINE(seed, applicationInfo.apiVersion);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AttachmentDescription const &attachmentDescription) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.flags);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.format);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.samples);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.loadOp);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.storeOp);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.stencilLoadOp);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.stencilStoreOp);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.initialLayout);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription.finalLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescription2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AttachmentDescription2 const &attachmentDescription2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.flags);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.format);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.samples);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.loadOp);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.storeOp);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.stencilLoadOp);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.stencilStoreOp);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.initialLayout);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescription2.finalLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const &attachmentDescriptionStencilLayout) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescriptionStencilLayout.sType);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescriptionStencilLayout.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescriptionStencilLayout.stencilInitialLayout);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentDescriptionStencilLayout.stencilFinalLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AttachmentReference const &attachmentReference) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReference.attachment);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReference.layout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentReference2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AttachmentReference2 const &attachmentReference2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReference2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReference2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReference2.attachment);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReference2.layout);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReference2.aspectMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const &attachmentReferenceStencilLayout) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReferenceStencilLayout.sType);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReferenceStencilLayout.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentReferenceStencilLayout.stencilLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const &attachmentSampleCountInfoAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, attachmentSampleCountInfoAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentSampleCountInfoAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentSampleCountInfoAMD.colorAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Extent2D>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Extent2D const &extent2D) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, extent2D.width);
		VULKAN_HPP_HASH_COMBINE(seed, extent2D.height);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SampleLocationEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SampleLocationEXT const &sampleLocationEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sampleLocationEXT.x);
		VULKAN_HPP_HASH_COMBINE(seed, sampleLocationEXT.y);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const &sampleLocationsInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sampleLocationsInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, sampleLocationsInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, sampleLocationsInfoEXT.sampleLocationsPerPixel);
		VULKAN_HPP_HASH_COMBINE(seed, sampleLocationsInfoEXT.sampleLocationGridSize);
		VULKAN_HPP_HASH_COMBINE(seed, sampleLocationsInfoEXT.sampleLocationsCount);
		VULKAN_HPP_HASH_COMBINE(seed, sampleLocationsInfoEXT.pSampleLocations);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const &attachmentSampleLocationsEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, attachmentSampleLocationsEXT.attachmentIndex);
		VULKAN_HPP_HASH_COMBINE(seed, attachmentSampleLocationsEXT.sampleLocationsInfo);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BaseInStructure>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BaseInStructure const &baseInStructure) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, baseInStructure.sType);
		VULKAN_HPP_HASH_COMBINE(seed, baseInStructure.pNext);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BaseOutStructure>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BaseOutStructure const &baseOutStructure) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, baseOutStructure.sType);
		VULKAN_HPP_HASH_COMBINE(seed, baseOutStructure.pNext);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const &bindAccelerationStructureMemoryInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindAccelerationStructureMemoryInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bindAccelerationStructureMemoryInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure);
		VULKAN_HPP_HASH_COMBINE(seed, bindAccelerationStructureMemoryInfoNV.memory);
		VULKAN_HPP_HASH_COMBINE(seed, bindAccelerationStructureMemoryInfoNV.memoryOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const &bindBufferMemoryDeviceGroupInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryDeviceGroupInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryDeviceGroupInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const &bindBufferMemoryInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryInfo.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryInfo.memory);
		VULKAN_HPP_HASH_COMBINE(seed, bindBufferMemoryInfo.memoryOffset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Offset2D>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Offset2D const &offset2D) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, offset2D.x);
		VULKAN_HPP_HASH_COMBINE(seed, offset2D.y);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Rect2D>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Rect2D const &rect2D) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, rect2D.offset);
		VULKAN_HPP_HASH_COMBINE(seed, rect2D.extent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const &bindImageMemoryDeviceGroupInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryDeviceGroupInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryDeviceGroupInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindImageMemoryInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const &bindImageMemoryInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryInfo.image);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryInfo.memory);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemoryInfo.memoryOffset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const &bindImageMemorySwapchainInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemorySwapchainInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemorySwapchainInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemorySwapchainInfoKHR.swapchain);
		VULKAN_HPP_HASH_COMBINE(seed, bindImageMemorySwapchainInfoKHR.imageIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const &bindImagePlaneMemoryInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindImagePlaneMemoryInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bindImagePlaneMemoryInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bindImagePlaneMemoryInfo.planeAspect);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const &bindIndexBufferIndirectCommandNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindIndexBufferIndirectCommandNV.bufferAddress);
		VULKAN_HPP_HASH_COMBINE(seed, bindIndexBufferIndirectCommandNV.size);
		VULKAN_HPP_HASH_COMBINE(seed, bindIndexBufferIndirectCommandNV.indexType);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const &bindShaderGroupIndirectCommandNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindShaderGroupIndirectCommandNV.groupIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseMemoryBind>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseMemoryBind const &sparseMemoryBind) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseMemoryBind.resourceOffset);
		VULKAN_HPP_HASH_COMBINE(seed, sparseMemoryBind.size);
		VULKAN_HPP_HASH_COMBINE(seed, sparseMemoryBind.memory);
		VULKAN_HPP_HASH_COMBINE(seed, sparseMemoryBind.memoryOffset);
		VULKAN_HPP_HASH_COMBINE(seed, sparseMemoryBind.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const &sparseBufferMemoryBindInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseBufferMemoryBindInfo.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, sparseBufferMemoryBindInfo.bindCount);
		VULKAN_HPP_HASH_COMBINE(seed, sparseBufferMemoryBindInfo.pBinds);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const &sparseImageOpaqueMemoryBindInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageOpaqueMemoryBindInfo.image);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageOpaqueMemoryBindInfo.bindCount);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageOpaqueMemoryBindInfo.pBinds);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageSubresource>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageSubresource const &imageSubresource) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresource.aspectMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresource.mipLevel);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresource.arrayLayer);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Offset3D>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Offset3D const &offset3D) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, offset3D.x);
		VULKAN_HPP_HASH_COMBINE(seed, offset3D.y);
		VULKAN_HPP_HASH_COMBINE(seed, offset3D.z);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Extent3D>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Extent3D const &extent3D) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, extent3D.width);
		VULKAN_HPP_HASH_COMBINE(seed, extent3D.height);
		VULKAN_HPP_HASH_COMBINE(seed, extent3D.depth);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBind>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const &sparseImageMemoryBind) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBind.subresource);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBind.offset);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBind.extent);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBind.memory);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBind.memoryOffset);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBind.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const &sparseImageMemoryBindInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBindInfo.image);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBindInfo.bindCount);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryBindInfo.pBinds);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindSparseInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindSparseInfo const &bindSparseInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.waitSemaphoreCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.pWaitSemaphores);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.bufferBindCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.pBufferBinds);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.imageOpaqueBindCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.pImageOpaqueBinds);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.imageBindCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.pImageBinds);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.signalSemaphoreCount);
		VULKAN_HPP_HASH_COMBINE(seed, bindSparseInfo.pSignalSemaphores);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const &bindVertexBufferIndirectCommandNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bindVertexBufferIndirectCommandNV.bufferAddress);
		VULKAN_HPP_HASH_COMBINE(seed, bindVertexBufferIndirectCommandNV.size);
		VULKAN_HPP_HASH_COMBINE(seed, bindVertexBufferIndirectCommandNV.stride);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceLayers>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const &imageSubresourceLayers) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceLayers.aspectMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceLayers.mipLevel);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceLayers.baseArrayLayer);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceLayers.layerCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageBlit2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageBlit2 const &imageBlit2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageBlit2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageBlit2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageBlit2.srcSubresource);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, imageBlit2.srcOffsets[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, imageBlit2.dstSubresource);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, imageBlit2.dstOffsets[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BlitImageInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BlitImageInfo2 const &blitImageInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.srcImage);
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.srcImageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.dstImage);
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.dstImageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.regionCount);
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.pRegions);
		VULKAN_HPP_HASH_COMBINE(seed, blitImageInfo2.filter);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const &bufferCollectionBufferCreateInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionBufferCreateInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionBufferCreateInfoFUCHSIA.collection);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionBufferCreateInfoFUCHSIA.index);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const &bufferCollectionConstraintsInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionConstraintsInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionConstraintsInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const &bufferCollectionCreateInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionCreateInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionCreateInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionCreateInfoFUCHSIA.collectionToken);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const &bufferCollectionImageCreateInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionImageCreateInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionImageCreateInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionImageCreateInfoFUCHSIA.collection);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionImageCreateInfoFUCHSIA.index);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const &sysmemColorSpaceFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sysmemColorSpaceFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, sysmemColorSpaceFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, sysmemColorSpaceFUCHSIA.colorSpace);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const &bufferCollectionPropertiesFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.bufferCount);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.formatFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferCreateInfo const &bufferCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCreateInfo.size);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCreateInfo.usage);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCreateInfo.sharingMode);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCreateInfo.queueFamilyIndexCount);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCreateInfo.pQueueFamilyIndices);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const &bufferConstraintsInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferConstraintsInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferConstraintsInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferConstraintsInfoFUCHSIA.createInfo);
		VULKAN_HPP_HASH_COMBINE(seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCopy>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferCopy const &bufferCopy) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferCopy.srcOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCopy.dstOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCopy.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferCopy2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferCopy2 const &bufferCopy2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferCopy2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCopy2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCopy2.srcOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCopy2.dstOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferCopy2.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const &bufferDeviceAddressCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferDeviceAddressCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferDeviceAddressCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferDeviceAddressCreateInfoEXT.deviceAddress);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const &bufferDeviceAddressInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferDeviceAddressInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferDeviceAddressInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferDeviceAddressInfo.buffer);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferImageCopy const &bufferImageCopy) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy.bufferOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy.bufferRowLength);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy.bufferImageHeight);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy.imageSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy.imageOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy.imageExtent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferImageCopy2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferImageCopy2 const &bufferImageCopy2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy2.bufferOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy2.bufferRowLength);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy2.bufferImageHeight);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy2.imageSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy2.imageOffset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferImageCopy2.imageExtent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const &bufferMemoryBarrier) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.srcAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.dstAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.srcQueueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.dstQueueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.offset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const &bufferMemoryBarrier2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.srcStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.srcAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.dstStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.dstAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.srcQueueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.dstQueueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.offset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryBarrier2.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const &bufferMemoryRequirementsInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryRequirementsInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryRequirementsInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferMemoryRequirementsInfo2.buffer);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const &bufferOpaqueCaptureAddressCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferOpaqueCaptureAddressCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferOpaqueCaptureAddressCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::BufferViewCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const &bufferViewCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, bufferViewCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, bufferViewCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, bufferViewCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, bufferViewCreateInfo.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, bufferViewCreateInfo.format);
		VULKAN_HPP_HASH_COMBINE(seed, bufferViewCreateInfo.offset);
		VULKAN_HPP_HASH_COMBINE(seed, bufferViewCreateInfo.range);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT const &calibratedTimestampInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, calibratedTimestampInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, calibratedTimestampInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, calibratedTimestampInfoEXT.timeDomain);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CheckpointData2NV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CheckpointData2NV const &checkpointData2NV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, checkpointData2NV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, checkpointData2NV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, checkpointData2NV.stage);
		VULKAN_HPP_HASH_COMBINE(seed, checkpointData2NV.pCheckpointMarker);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CheckpointDataNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CheckpointDataNV const &checkpointDataNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, checkpointDataNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, checkpointDataNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, checkpointDataNV.stage);
		VULKAN_HPP_HASH_COMBINE(seed, checkpointDataNV.pCheckpointMarker);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ClearDepthStencilValue>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const &clearDepthStencilValue) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, clearDepthStencilValue.depth);
		VULKAN_HPP_HASH_COMBINE(seed, clearDepthStencilValue.stencil);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ClearRect>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ClearRect const &clearRect) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, clearRect.rect);
		VULKAN_HPP_HASH_COMBINE(seed, clearRect.baseArrayLayer);
		VULKAN_HPP_HASH_COMBINE(seed, clearRect.layerCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const &coarseSampleLocationNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, coarseSampleLocationNV.pixelX);
		VULKAN_HPP_HASH_COMBINE(seed, coarseSampleLocationNV.pixelY);
		VULKAN_HPP_HASH_COMBINE(seed, coarseSampleLocationNV.sample);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const &coarseSampleOrderCustomNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, coarseSampleOrderCustomNV.shadingRate);
		VULKAN_HPP_HASH_COMBINE(seed, coarseSampleOrderCustomNV.sampleCount);
		VULKAN_HPP_HASH_COMBINE(seed, coarseSampleOrderCustomNV.sampleLocationCount);
		VULKAN_HPP_HASH_COMBINE(seed, coarseSampleOrderCustomNV.pSampleLocations);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const &commandBufferAllocateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferAllocateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferAllocateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferAllocateInfo.commandPool);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferAllocateInfo.level);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferAllocateInfo.commandBufferCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const &commandBufferInheritanceInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceInfo.renderPass);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceInfo.subpass);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceInfo.framebuffer);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceInfo.occlusionQueryEnable);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceInfo.queryFlags);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceInfo.pipelineStatistics);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const &commandBufferBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferBeginInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferBeginInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferBeginInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferBeginInfo.pInheritanceInfo);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const &commandBufferInheritanceConditionalRenderingInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const &commandBufferInheritanceRenderPassTransformInfoQCOM) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const &commandBufferInheritanceRenderingInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.viewMask);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceRenderingInfo.rasterizationSamples);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::Viewport>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Viewport const &viewport) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, viewport.x);
		VULKAN_HPP_HASH_COMBINE(seed, viewport.y);
		VULKAN_HPP_HASH_COMBINE(seed, viewport.width);
		VULKAN_HPP_HASH_COMBINE(seed, viewport.height);
		VULKAN_HPP_HASH_COMBINE(seed, viewport.minDepth);
		VULKAN_HPP_HASH_COMBINE(seed, viewport.maxDepth);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const &commandBufferInheritanceViewportScissorInfoNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceViewportScissorInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceViewportScissorInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const &commandBufferSubmitInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferSubmitInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferSubmitInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferSubmitInfo.commandBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, commandBufferSubmitInfo.deviceMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const &commandPoolCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, commandPoolCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, commandPoolCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, commandPoolCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, commandPoolCreateInfo.queueFamilyIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SpecializationMapEntry>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SpecializationMapEntry const &specializationMapEntry) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, specializationMapEntry.constantID);
		VULKAN_HPP_HASH_COMBINE(seed, specializationMapEntry.offset);
		VULKAN_HPP_HASH_COMBINE(seed, specializationMapEntry.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SpecializationInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SpecializationInfo const &specializationInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, specializationInfo.mapEntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, specializationInfo.pMapEntries);
		VULKAN_HPP_HASH_COMBINE(seed, specializationInfo.dataSize);
		VULKAN_HPP_HASH_COMBINE(seed, specializationInfo.pData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const &pipelineShaderStageCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageCreateInfo.stage);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageCreateInfo.module);
		for(const char *p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageCreateInfo.pSpecializationInfo);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const &computePipelineCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, computePipelineCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, computePipelineCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, computePipelineCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, computePipelineCreateInfo.stage);
		VULKAN_HPP_HASH_COMBINE(seed, computePipelineCreateInfo.layout);
		VULKAN_HPP_HASH_COMBINE(seed, computePipelineCreateInfo.basePipelineHandle);
		VULKAN_HPP_HASH_COMBINE(seed, computePipelineCreateInfo.basePipelineIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const &conditionalRenderingBeginInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, conditionalRenderingBeginInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, conditionalRenderingBeginInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, conditionalRenderingBeginInfoEXT.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, conditionalRenderingBeginInfoEXT.offset);
		VULKAN_HPP_HASH_COMBINE(seed, conditionalRenderingBeginInfoEXT.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ConformanceVersion>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ConformanceVersion const &conformanceVersion) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, conformanceVersion.major);
		VULKAN_HPP_HASH_COMBINE(seed, conformanceVersion.minor);
		VULKAN_HPP_HASH_COMBINE(seed, conformanceVersion.subminor);
		VULKAN_HPP_HASH_COMBINE(seed, conformanceVersion.patch);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const &cooperativeMatrixPropertiesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.MSize);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.NSize);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.KSize);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.AType);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.BType);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.CType);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.DType);
		VULKAN_HPP_HASH_COMBINE(seed, cooperativeMatrixPropertiesNV.scope);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const &copyAccelerationStructureInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, copyAccelerationStructureInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, copyAccelerationStructureInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, copyAccelerationStructureInfoKHR.src);
		VULKAN_HPP_HASH_COMBINE(seed, copyAccelerationStructureInfoKHR.dst);
		VULKAN_HPP_HASH_COMBINE(seed, copyAccelerationStructureInfoKHR.mode);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CopyBufferInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const &copyBufferInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferInfo2.srcBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferInfo2.dstBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferInfo2.regionCount);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferInfo2.pRegions);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const &copyBufferToImageInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferToImageInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferToImageInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferToImageInfo2.srcBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferToImageInfo2.dstImage);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferToImageInfo2.dstImageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferToImageInfo2.regionCount);
		VULKAN_HPP_HASH_COMBINE(seed, copyBufferToImageInfo2.pRegions);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const &copyCommandTransformInfoQCOM) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, copyCommandTransformInfoQCOM.sType);
		VULKAN_HPP_HASH_COMBINE(seed, copyCommandTransformInfoQCOM.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, copyCommandTransformInfoQCOM.transform);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CopyDescriptorSet>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CopyDescriptorSet const &copyDescriptorSet) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.sType);
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.srcSet);
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.srcBinding);
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.srcArrayElement);
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.dstSet);
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.dstBinding);
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.dstArrayElement);
		VULKAN_HPP_HASH_COMBINE(seed, copyDescriptorSet.descriptorCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageCopy2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageCopy2 const &imageCopy2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy2.srcSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy2.srcOffset);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy2.dstSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy2.dstOffset);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy2.extent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CopyImageInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CopyImageInfo2 const &copyImageInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, copyImageInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageInfo2.srcImage);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageInfo2.srcImageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageInfo2.dstImage);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageInfo2.dstImageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageInfo2.regionCount);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageInfo2.pRegions);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const &copyImageToBufferInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, copyImageToBufferInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageToBufferInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageToBufferInfo2.srcImage);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageToBufferInfo2.srcImageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageToBufferInfo2.dstBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageToBufferInfo2.regionCount);
		VULKAN_HPP_HASH_COMBINE(seed, copyImageToBufferInfo2.pRegions);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const &cuFunctionCreateInfoNVX) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, cuFunctionCreateInfoNVX.sType);
		VULKAN_HPP_HASH_COMBINE(seed, cuFunctionCreateInfoNVX.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, cuFunctionCreateInfoNVX.module);
		for(const char *p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const &cuLaunchInfoNVX) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.sType);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.function);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.gridDimX);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.gridDimY);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.gridDimZ);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.blockDimX);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.blockDimY);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.blockDimZ);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.sharedMemBytes);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.paramCount);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.pParams);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.extraCount);
		VULKAN_HPP_HASH_COMBINE(seed, cuLaunchInfoNVX.pExtras);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const &cuModuleCreateInfoNVX) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, cuModuleCreateInfoNVX.sType);
		VULKAN_HPP_HASH_COMBINE(seed, cuModuleCreateInfoNVX.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, cuModuleCreateInfoNVX.dataSize);
		VULKAN_HPP_HASH_COMBINE(seed, cuModuleCreateInfoNVX.pData);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const &d3D12FenceSubmitInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, d3D12FenceSubmitInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, d3D12FenceSubmitInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount);
		VULKAN_HPP_HASH_COMBINE(seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues);
		VULKAN_HPP_HASH_COMBINE(seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount);
		VULKAN_HPP_HASH_COMBINE(seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const &debugMarkerMarkerInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerMarkerInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerMarkerInfoEXT.pNext);
		for(const char *p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		for(size_t i = 0; i < 4; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, debugMarkerMarkerInfoEXT.color[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const &debugMarkerObjectNameInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectNameInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectNameInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectNameInfoEXT.objectType);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectNameInfoEXT.object);
		for(const char *p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const &debugMarkerObjectTagInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectTagInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectTagInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectTagInfoEXT.objectType);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectTagInfoEXT.object);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectTagInfoEXT.tagName);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectTagInfoEXT.tagSize);
		VULKAN_HPP_HASH_COMBINE(seed, debugMarkerObjectTagInfoEXT.pTag);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const &debugReportCallbackCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugReportCallbackCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugReportCallbackCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, debugReportCallbackCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, debugReportCallbackCreateInfoEXT.pfnCallback);
		VULKAN_HPP_HASH_COMBINE(seed, debugReportCallbackCreateInfoEXT.pUserData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const &debugUtilsLabelEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsLabelEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsLabelEXT.pNext);
		for(const char *p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		for(size_t i = 0; i < 4; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, debugUtilsLabelEXT.color[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const &debugUtilsObjectNameInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectNameInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectNameInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectNameInfoEXT.objectType);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectNameInfoEXT.objectHandle);
		for(const char *p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const &debugUtilsMessengerCallbackDataEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.flags);
		for(const char *p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber);
		for(const char *p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.objectCount);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCallbackDataEXT.pObjects);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const &debugUtilsMessengerCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCreateInfoEXT.messageSeverity);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCreateInfoEXT.messageType);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsMessengerCreateInfoEXT.pUserData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const &debugUtilsObjectTagInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectTagInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectTagInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectTagInfoEXT.objectType);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectTagInfoEXT.objectHandle);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectTagInfoEXT.tagName);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectTagInfoEXT.tagSize);
		VULKAN_HPP_HASH_COMBINE(seed, debugUtilsObjectTagInfoEXT.pTag);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const &dedicatedAllocationBufferCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationBufferCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationBufferCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const &dedicatedAllocationImageCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationImageCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationImageCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const &dedicatedAllocationMemoryAllocateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationMemoryAllocateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationMemoryAllocateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationMemoryAllocateInfoNV.image);
		VULKAN_HPP_HASH_COMBINE(seed, dedicatedAllocationMemoryAllocateInfoNV.buffer);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryBarrier2 const &memoryBarrier2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier2.srcStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier2.srcAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier2.dstStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier2.dstAccessMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageSubresourceRange>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageSubresourceRange const &imageSubresourceRange) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceRange.aspectMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceRange.baseMipLevel);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceRange.levelCount);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceRange.baseArrayLayer);
		VULKAN_HPP_HASH_COMBINE(seed, imageSubresourceRange.layerCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const &imageMemoryBarrier2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.srcStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.srcAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.dstStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.dstAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.oldLayout);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.newLayout);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.srcQueueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.dstQueueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.image);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier2.subresourceRange);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DependencyInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DependencyInfo const &dependencyInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.dependencyFlags);
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.memoryBarrierCount);
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.pMemoryBarriers);
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.bufferMemoryBarrierCount);
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.pBufferMemoryBarriers);
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.imageMemoryBarrierCount);
		VULKAN_HPP_HASH_COMBINE(seed, dependencyInfo.pImageMemoryBarriers);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorBufferInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const &descriptorBufferInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorBufferInfo.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorBufferInfo.offset);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorBufferInfo.range);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorImageInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorImageInfo const &descriptorImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorImageInfo.sampler);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorImageInfo.imageView);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorImageInfo.imageLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolSize>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorPoolSize const &descriptorPoolSize) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolSize.type);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolSize.descriptorCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const &descriptorPoolCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolCreateInfo.maxSets);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolCreateInfo.poolSizeCount);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolCreateInfo.pPoolSizes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const &descriptorPoolInlineUniformBlockCreateInfo) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolInlineUniformBlockCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolInlineUniformBlockCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const &descriptorSetAllocateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetAllocateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetAllocateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetAllocateInfo.descriptorPool);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetAllocateInfo.descriptorSetCount);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetAllocateInfo.pSetLayouts);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const &descriptorSetBindingReferenceVALVE) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetBindingReferenceVALVE.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetBindingReferenceVALVE.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetBindingReferenceVALVE.binding);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const &descriptorSetLayoutBinding) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBinding.binding);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBinding.descriptorType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBinding.descriptorCount);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBinding.stageFlags);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBinding.pImmutableSamplers);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const &descriptorSetLayoutBindingFlagsCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBindingFlagsCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const &descriptorSetLayoutCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutCreateInfo.bindingCount);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutCreateInfo.pBindings);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const &descriptorSetLayoutHostMappingInfoVALVE) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutHostMappingInfoVALVE.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutHostMappingInfoVALVE.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const &descriptorSetLayoutSupport) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutSupport.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutSupport.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetLayoutSupport.supported);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const &descriptorSetVariableDescriptorCountAllocateInfo)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetVariableDescriptorCountAllocateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const &descriptorSetVariableDescriptorCountLayoutSupport)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetVariableDescriptorCountLayoutSupport.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const &descriptorUpdateTemplateEntry) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateEntry.dstBinding);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateEntry.dstArrayElement);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateEntry.descriptorCount);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateEntry.descriptorType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateEntry.offset);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateEntry.stride);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const &descriptorUpdateTemplateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.templateType);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.pipelineLayout);
		VULKAN_HPP_HASH_COMBINE(seed, descriptorUpdateTemplateCreateInfo.set);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const &deviceBufferMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceBufferMemoryRequirements.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceBufferMemoryRequirements.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceBufferMemoryRequirements.pCreateInfo);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const &deviceQueueCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueCreateInfo.queueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueCreateInfo.queueCount);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueCreateInfo.pQueuePriorities);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const &physicalDeviceFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.robustBufferAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.fullDrawIndexUint32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.imageCubeArray);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.independentBlend);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.geometryShader);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.tessellationShader);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sampleRateShading);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.dualSrcBlend);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.logicOp);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.multiDrawIndirect);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.drawIndirectFirstInstance);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.depthClamp);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.depthBiasClamp);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.fillModeNonSolid);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.depthBounds);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.wideLines);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.largePoints);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.alphaToOne);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.multiViewport);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.samplerAnisotropy);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.textureCompressionETC2);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.textureCompressionASTC_LDR);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.textureCompressionBC);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.occlusionQueryPrecise);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.pipelineStatisticsQuery);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.fragmentStoresAndAtomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderImageGatherExtended);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderStorageImageMultisample);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderClipDistance);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderCullDistance);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderInt64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderInt16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderResourceResidency);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.shaderResourceMinLod);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseBinding);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseResidencyBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseResidencyImage2D);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseResidencyImage3D);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseResidency2Samples);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseResidency4Samples);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseResidency8Samples);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseResidency16Samples);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.sparseResidencyAliased);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.variableMultisampleRate);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures.inheritedQueries);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceCreateInfo const &deviceCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, deviceCreateInfo.queueCreateInfoCount);
		VULKAN_HPP_HASH_COMBINE(seed, deviceCreateInfo.pQueueCreateInfos);
		VULKAN_HPP_HASH_COMBINE(seed, deviceCreateInfo.enabledLayerCount);
		for(size_t i = 0; i < deviceCreateInfo.enabledLayerCount; ++i)
		{
			for(const char *p = deviceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p)
			{
				VULKAN_HPP_HASH_COMBINE(seed, *p);
			}
		}
		VULKAN_HPP_HASH_COMBINE(seed, deviceCreateInfo.enabledExtensionCount);
		for(size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i)
		{
			for(const char *p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p)
			{
				VULKAN_HPP_HASH_COMBINE(seed, *p);
			}
		}
		VULKAN_HPP_HASH_COMBINE(seed, deviceCreateInfo.pEnabledFeatures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const &deviceDeviceMemoryReportCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceDeviceMemoryReportCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceDeviceMemoryReportCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceDeviceMemoryReportCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback);
		VULKAN_HPP_HASH_COMBINE(seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const &deviceDiagnosticsConfigCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceDiagnosticsConfigCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceDiagnosticsConfigCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceDiagnosticsConfigCreateInfoNV.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const &deviceEventInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceEventInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceEventInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceEventInfoEXT.deviceEvent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const &deviceGroupBindSparseInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupBindSparseInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupBindSparseInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupBindSparseInfo.resourceDeviceIndex);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupBindSparseInfo.memoryDeviceIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const &deviceGroupCommandBufferBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupCommandBufferBeginInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupCommandBufferBeginInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupCommandBufferBeginInfo.deviceMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const &deviceGroupDeviceCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupDeviceCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupDeviceCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupDeviceCreateInfo.physicalDeviceCount);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupDeviceCreateInfo.pPhysicalDevices);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const &deviceGroupPresentCapabilitiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentCapabilitiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentCapabilitiesKHR.pNext);
		for(size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentCapabilitiesKHR.presentMask[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentCapabilitiesKHR.modes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const &deviceGroupPresentInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentInfoKHR.swapchainCount);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentInfoKHR.pDeviceMasks);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupPresentInfoKHR.mode);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const &deviceGroupRenderPassBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupRenderPassBeginInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupRenderPassBeginInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupRenderPassBeginInfo.deviceMask);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const &deviceGroupSubmitInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSubmitInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSubmitInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSubmitInfo.waitSemaphoreCount);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSubmitInfo.commandBufferCount);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSubmitInfo.signalSemaphoreCount);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const &deviceGroupSwapchainCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSwapchainCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSwapchainCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceGroupSwapchainCreateInfoKHR.modes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageCreateInfo const &imageCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.imageType);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.format);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.extent);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.mipLevels);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.arrayLayers);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.samples);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.tiling);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.usage);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.sharingMode);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.queueFamilyIndexCount);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.pQueueFamilyIndices);
		VULKAN_HPP_HASH_COMBINE(seed, imageCreateInfo.initialLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const &deviceImageMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceImageMemoryRequirements.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceImageMemoryRequirements.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceImageMemoryRequirements.pCreateInfo);
		VULKAN_HPP_HASH_COMBINE(seed, deviceImageMemoryRequirements.planeAspect);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const &deviceMemoryOpaqueCaptureAddressInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryOpaqueCaptureAddressInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryOpaqueCaptureAddressInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryOpaqueCaptureAddressInfo.memory);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const &deviceMemoryOverallocationCreateInfoAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryOverallocationCreateInfoAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryOverallocationCreateInfoAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const &deviceMemoryReportCallbackDataEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.type);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.memoryObjectId);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.size);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.objectType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.objectHandle);
		VULKAN_HPP_HASH_COMBINE(seed, deviceMemoryReportCallbackDataEXT.heapIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const &devicePrivateDataCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, devicePrivateDataCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, devicePrivateDataCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR const &deviceQueueGlobalPriorityCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueGlobalPriorityCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueGlobalPriorityCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueGlobalPriorityCreateInfoKHR.globalPriority);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DeviceQueueInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const &deviceQueueInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueInfo2.flags);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueInfo2.queueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, deviceQueueInfo2.queueIndex);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_DIRECTFB_EXT)
template<>
struct hash<VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const &directFBSurfaceCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, directFBSurfaceCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, directFBSurfaceCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, directFBSurfaceCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, directFBSurfaceCreateInfoEXT.dfb);
		VULKAN_HPP_HASH_COMBINE(seed, directFBSurfaceCreateInfoEXT.surface);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::DispatchIndirectCommand>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const &dispatchIndirectCommand) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, dispatchIndirectCommand.x);
		VULKAN_HPP_HASH_COMBINE(seed, dispatchIndirectCommand.y);
		VULKAN_HPP_HASH_COMBINE(seed, dispatchIndirectCommand.z);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const &displayEventInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayEventInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayEventInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayEventInfoEXT.displayEvent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const &displayModeParametersKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayModeParametersKHR.visibleRegion);
		VULKAN_HPP_HASH_COMBINE(seed, displayModeParametersKHR.refreshRate);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const &displayModeCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayModeCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayModeCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayModeCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, displayModeCreateInfoKHR.parameters);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const &displayModePropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayModePropertiesKHR.displayMode);
		VULKAN_HPP_HASH_COMBINE(seed, displayModePropertiesKHR.parameters);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const &displayModeProperties2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayModeProperties2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayModeProperties2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayModeProperties2KHR.displayModeProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const &displayNativeHdrSurfaceCapabilitiesAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayNativeHdrSurfaceCapabilitiesAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const &displayPlaneCapabilitiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.supportedAlpha);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.minSrcPosition);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.maxSrcPosition);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.minSrcExtent);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.maxSrcExtent);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.minDstPosition);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.maxDstPosition);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.minDstExtent);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilitiesKHR.maxDstExtent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const &displayPlaneCapabilities2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilities2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilities2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneCapabilities2KHR.capabilities);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const &displayPlaneInfo2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneInfo2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneInfo2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneInfo2KHR.mode);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneInfo2KHR.planeIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const &displayPlanePropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayPlanePropertiesKHR.currentDisplay);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlanePropertiesKHR.currentStackIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const &displayPlaneProperties2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneProperties2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneProperties2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayPlaneProperties2KHR.displayPlaneProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const &displayPowerInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayPowerInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayPowerInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayPowerInfoEXT.powerState);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const &displayPresentInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayPresentInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayPresentInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayPresentInfoKHR.srcRect);
		VULKAN_HPP_HASH_COMBINE(seed, displayPresentInfoKHR.dstRect);
		VULKAN_HPP_HASH_COMBINE(seed, displayPresentInfoKHR.persistent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const &displayPropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayPropertiesKHR.display);
		for(const char *p = displayPropertiesKHR.displayName; *p != '\0'; ++p)
		{
			VULKAN_HPP_HASH_COMBINE(seed, *p);
		}
		VULKAN_HPP_HASH_COMBINE(seed, displayPropertiesKHR.physicalDimensions);
		VULKAN_HPP_HASH_COMBINE(seed, displayPropertiesKHR.physicalResolution);
		VULKAN_HPP_HASH_COMBINE(seed, displayPropertiesKHR.supportedTransforms);
		VULKAN_HPP_HASH_COMBINE(seed, displayPropertiesKHR.planeReorderPossible);
		VULKAN_HPP_HASH_COMBINE(seed, displayPropertiesKHR.persistentContent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplayProperties2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const &displayProperties2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displayProperties2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displayProperties2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displayProperties2KHR.displayProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const &displaySurfaceCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.displayMode);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.planeIndex);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.planeStackIndex);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.transform);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.globalAlpha);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.alphaMode);
		VULKAN_HPP_HASH_COMBINE(seed, displaySurfaceCreateInfoKHR.imageExtent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const &drawIndexedIndirectCommand) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, drawIndexedIndirectCommand.indexCount);
		VULKAN_HPP_HASH_COMBINE(seed, drawIndexedIndirectCommand.instanceCount);
		VULKAN_HPP_HASH_COMBINE(seed, drawIndexedIndirectCommand.firstIndex);
		VULKAN_HPP_HASH_COMBINE(seed, drawIndexedIndirectCommand.vertexOffset);
		VULKAN_HPP_HASH_COMBINE(seed, drawIndexedIndirectCommand.firstInstance);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DrawIndirectCommand>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DrawIndirectCommand const &drawIndirectCommand) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, drawIndirectCommand.vertexCount);
		VULKAN_HPP_HASH_COMBINE(seed, drawIndirectCommand.instanceCount);
		VULKAN_HPP_HASH_COMBINE(seed, drawIndirectCommand.firstVertex);
		VULKAN_HPP_HASH_COMBINE(seed, drawIndirectCommand.firstInstance);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const &drawMeshTasksIndirectCommandNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, drawMeshTasksIndirectCommandNV.taskCount);
		VULKAN_HPP_HASH_COMBINE(seed, drawMeshTasksIndirectCommandNV.firstTask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const &drmFormatModifierProperties2EXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierProperties2EXT.drmFormatModifier);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const &drmFormatModifierPropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesEXT.drmFormatModifier);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const &drmFormatModifierPropertiesList2EXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesList2EXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesList2EXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const &drmFormatModifierPropertiesListEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesListEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesListEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount);
		VULKAN_HPP_HASH_COMBINE(seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::EventCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::EventCreateInfo const &eventCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, eventCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, eventCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, eventCreateInfo.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const &exportFenceCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, exportFenceCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, exportFenceCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, exportFenceCreateInfo.handleTypes);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const &exportFenceWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, exportFenceWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, exportFenceWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, exportFenceWin32HandleInfoKHR.pAttributes);
		VULKAN_HPP_HASH_COMBINE(seed, exportFenceWin32HandleInfoKHR.dwAccess);
		VULKAN_HPP_HASH_COMBINE(seed, exportFenceWin32HandleInfoKHR.name);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const &exportMemoryAllocateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryAllocateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryAllocateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryAllocateInfo.handleTypes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const &exportMemoryAllocateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryAllocateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryAllocateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryAllocateInfoNV.handleTypes);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const &exportMemoryWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoKHR.pAttributes);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoKHR.dwAccess);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoKHR.name);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const &exportMemoryWin32HandleInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoNV.pAttributes);
		VULKAN_HPP_HASH_COMBINE(seed, exportMemoryWin32HandleInfoNV.dwAccess);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const &exportSemaphoreCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, exportSemaphoreCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, exportSemaphoreCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, exportSemaphoreCreateInfo.handleTypes);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const &exportSemaphoreWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, exportSemaphoreWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, exportSemaphoreWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, exportSemaphoreWin32HandleInfoKHR.pAttributes);
		VULKAN_HPP_HASH_COMBINE(seed, exportSemaphoreWin32HandleInfoKHR.dwAccess);
		VULKAN_HPP_HASH_COMBINE(seed, exportSemaphoreWin32HandleInfoKHR.name);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExtensionProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExtensionProperties const &extensionProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		for(size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, extensionProperties.extensionName[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, extensionProperties.specVersion);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const &externalMemoryProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryProperties.externalMemoryFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryProperties.exportFromImportedHandleTypes);
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryProperties.compatibleHandleTypes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalBufferProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalBufferProperties const &externalBufferProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalBufferProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, externalBufferProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, externalBufferProperties.externalMemoryProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalFenceProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalFenceProperties const &externalFenceProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalFenceProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, externalFenceProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, externalFenceProperties.exportFromImportedHandleTypes);
		VULKAN_HPP_HASH_COMBINE(seed, externalFenceProperties.compatibleHandleTypes);
		VULKAN_HPP_HASH_COMBINE(seed, externalFenceProperties.externalFenceFeatures);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalFormatANDROID>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const &externalFormatANDROID) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalFormatANDROID.sType);
		VULKAN_HPP_HASH_COMBINE(seed, externalFormatANDROID.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, externalFormatANDROID.externalFormat);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const &externalImageFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalImageFormatProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, externalImageFormatProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, externalImageFormatProperties.externalMemoryProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageFormatProperties const &imageFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatProperties.maxExtent);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatProperties.maxMipLevels);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatProperties.maxArrayLayers);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatProperties.sampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatProperties.maxResourceSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const &externalImageFormatPropertiesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalImageFormatPropertiesNV.imageFormatProperties);
		VULKAN_HPP_HASH_COMBINE(seed, externalImageFormatPropertiesNV.externalMemoryFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes);
		VULKAN_HPP_HASH_COMBINE(seed, externalImageFormatPropertiesNV.compatibleHandleTypes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const &externalMemoryBufferCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryBufferCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryBufferCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryBufferCreateInfo.handleTypes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const &externalMemoryImageCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryImageCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryImageCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryImageCreateInfo.handleTypes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const &externalMemoryImageCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryImageCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryImageCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, externalMemoryImageCreateInfoNV.handleTypes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const &externalSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, externalSemaphoreProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, externalSemaphoreProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, externalSemaphoreProperties.exportFromImportedHandleTypes);
		VULKAN_HPP_HASH_COMBINE(seed, externalSemaphoreProperties.compatibleHandleTypes);
		VULKAN_HPP_HASH_COMBINE(seed, externalSemaphoreProperties.externalSemaphoreFeatures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FenceCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FenceCreateInfo const &fenceCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, fenceCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, fenceCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, fenceCreateInfo.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const &fenceGetFdInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, fenceGetFdInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, fenceGetFdInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, fenceGetFdInfoKHR.fence);
		VULKAN_HPP_HASH_COMBINE(seed, fenceGetFdInfoKHR.handleType);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const &fenceGetWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, fenceGetWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, fenceGetWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, fenceGetWin32HandleInfoKHR.fence);
		VULKAN_HPP_HASH_COMBINE(seed, fenceGetWin32HandleInfoKHR.handleType);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const &filterCubicImageViewImageFormatPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, filterCubicImageViewImageFormatPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, filterCubicImageViewImageFormatPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic);
		VULKAN_HPP_HASH_COMBINE(seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FormatProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FormatProperties const &formatProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties.linearTilingFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties.optimalTilingFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties.bufferFeatures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FormatProperties2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FormatProperties2 const &formatProperties2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties2.formatProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FormatProperties3>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FormatProperties3 const &formatProperties3) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties3.sType);
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties3.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties3.linearTilingFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties3.optimalTilingFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, formatProperties3.bufferFeatures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const &fragmentShadingRateAttachmentInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, fragmentShadingRateAttachmentInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, fragmentShadingRateAttachmentInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment);
		VULKAN_HPP_HASH_COMBINE(seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const &framebufferAttachmentImageInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.usage);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.width);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.height);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.layerCount);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.viewFormatCount);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentImageInfo.pViewFormats);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const &framebufferAttachmentsCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentsCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentsCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FramebufferCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const &framebufferCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.renderPass);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.attachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.pAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.width);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.height);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferCreateInfo.layers);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const &framebufferMixedSamplesCombinationNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, framebufferMixedSamplesCombinationNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferMixedSamplesCombinationNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferMixedSamplesCombinationNV.coverageReductionMode);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferMixedSamplesCombinationNV.rasterizationSamples);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferMixedSamplesCombinationNV.depthStencilSamples);
		VULKAN_HPP_HASH_COMBINE(seed, framebufferMixedSamplesCombinationNV.colorSamples);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const &indirectCommandsStreamNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsStreamNV.buffer);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsStreamNV.offset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const &generatedCommandsInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.pipelineBindPoint);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.pipeline);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.indirectCommandsLayout);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.streamCount);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.pStreams);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.sequencesCount);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.preprocessBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.preprocessOffset);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.preprocessSize);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.sequencesCountBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.sequencesCountOffset);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.sequencesIndexBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsInfoNV.sequencesIndexOffset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const &generatedCommandsMemoryRequirementsInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsMemoryRequirementsInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsMemoryRequirementsInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsMemoryRequirementsInfoNV.pipeline);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout);
		VULKAN_HPP_HASH_COMBINE(seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const &vertexInputBindingDescription) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription.binding);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription.stride);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription.inputRate);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const &vertexInputAttributeDescription) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription.location);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription.binding);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription.format);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription.offset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const &pipelineVertexInputStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const &pipelineInputAssemblyStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineInputAssemblyStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineInputAssemblyStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineInputAssemblyStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineInputAssemblyStateCreateInfo.topology);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const &pipelineTessellationStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineTessellationStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineTessellationStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineTessellationStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineTessellationStateCreateInfo.patchControlPoints);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const &pipelineViewportStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportStateCreateInfo.viewportCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportStateCreateInfo.pViewports);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportStateCreateInfo.scissorCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportStateCreateInfo.pScissors);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const &pipelineRasterizationStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.depthClampEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.polygonMode);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.cullMode);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.frontFace);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.depthBiasEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.depthBiasClamp);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateCreateInfo.lineWidth);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const &pipelineMultisampleStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.rasterizationSamples);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.minSampleShading);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.pSampleMask);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::StencilOpState>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::StencilOpState const &stencilOpState) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, stencilOpState.failOp);
		VULKAN_HPP_HASH_COMBINE(seed, stencilOpState.passOp);
		VULKAN_HPP_HASH_COMBINE(seed, stencilOpState.depthFailOp);
		VULKAN_HPP_HASH_COMBINE(seed, stencilOpState.compareOp);
		VULKAN_HPP_HASH_COMBINE(seed, stencilOpState.compareMask);
		VULKAN_HPP_HASH_COMBINE(seed, stencilOpState.writeMask);
		VULKAN_HPP_HASH_COMBINE(seed, stencilOpState.reference);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const &pipelineDepthStencilStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.depthTestEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.depthCompareOp);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.front);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.back);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.minDepthBounds);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const &pipelineColorBlendAttachmentState) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAttachmentState.blendEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAttachmentState.srcColorBlendFactor);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAttachmentState.dstColorBlendFactor);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAttachmentState.colorBlendOp);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAttachmentState.alphaBlendOp);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAttachmentState.colorWriteMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const &pipelineColorBlendStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendStateCreateInfo.logicOpEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendStateCreateInfo.logicOp);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendStateCreateInfo.attachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendStateCreateInfo.pAttachments);
		for(size_t i = 0; i < 4; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendStateCreateInfo.blendConstants[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const &pipelineDynamicStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDynamicStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDynamicStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDynamicStateCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDynamicStateCreateInfo.dynamicStateCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDynamicStateCreateInfo.pDynamicStates);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const &graphicsPipelineCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.stageCount);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pStages);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pVertexInputState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pInputAssemblyState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pTessellationState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pViewportState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pRasterizationState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pMultisampleState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pDepthStencilState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pColorBlendState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.pDynamicState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.layout);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.renderPass);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.subpass);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.basePipelineHandle);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineCreateInfo.basePipelineIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const &graphicsPipelineLibraryCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineLibraryCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineLibraryCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineLibraryCreateInfoEXT.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const &graphicsShaderGroupCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, graphicsShaderGroupCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsShaderGroupCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsShaderGroupCreateInfoNV.stageCount);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsShaderGroupCreateInfoNV.pStages);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsShaderGroupCreateInfoNV.pVertexInputState);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsShaderGroupCreateInfoNV.pTessellationState);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const &graphicsPipelineShaderGroupsCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineShaderGroupsCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount);
		VULKAN_HPP_HASH_COMBINE(seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::XYColorEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::XYColorEXT const &xYColorEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, xYColorEXT.x);
		VULKAN_HPP_HASH_COMBINE(seed, xYColorEXT.y);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::HdrMetadataEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::HdrMetadataEXT const &hdrMetadataEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.displayPrimaryRed);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.displayPrimaryGreen);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.displayPrimaryBlue);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.whitePoint);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.maxLuminance);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.minLuminance);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.maxContentLightLevel);
		VULKAN_HPP_HASH_COMBINE(seed, hdrMetadataEXT.maxFrameAverageLightLevel);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const &headlessSurfaceCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, headlessSurfaceCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, headlessSurfaceCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, headlessSurfaceCreateInfoEXT.flags);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_IOS_MVK)
template<>
struct hash<VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const &iOSSurfaceCreateInfoMVK) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, iOSSurfaceCreateInfoMVK.sType);
		VULKAN_HPP_HASH_COMBINE(seed, iOSSurfaceCreateInfoMVK.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, iOSSurfaceCreateInfoMVK.flags);
		VULKAN_HPP_HASH_COMBINE(seed, iOSSurfaceCreateInfoMVK.pView);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_IOS_MVK*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageBlit>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageBlit const &imageBlit) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageBlit.srcSubresource);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, imageBlit.srcOffsets[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, imageBlit.dstSubresource);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, imageBlit.dstOffsets[i]);
		}
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const &imageFormatConstraintsInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatConstraintsInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatConstraintsInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatConstraintsInfoFUCHSIA.flags);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const &imageConstraintsInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageConstraintsInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageConstraintsInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount);
		VULKAN_HPP_HASH_COMBINE(seed, imageConstraintsInfoFUCHSIA.pFormatConstraints);
		VULKAN_HPP_HASH_COMBINE(seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints);
		VULKAN_HPP_HASH_COMBINE(seed, imageConstraintsInfoFUCHSIA.flags);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageCopy>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageCopy const &imageCopy) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy.srcSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy.srcOffset);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy.dstSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy.dstOffset);
		VULKAN_HPP_HASH_COMBINE(seed, imageCopy.extent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubresourceLayout>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubresourceLayout const &subresourceLayout) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subresourceLayout.offset);
		VULKAN_HPP_HASH_COMBINE(seed, subresourceLayout.size);
		VULKAN_HPP_HASH_COMBINE(seed, subresourceLayout.rowPitch);
		VULKAN_HPP_HASH_COMBINE(seed, subresourceLayout.arrayPitch);
		VULKAN_HPP_HASH_COMBINE(seed, subresourceLayout.depthPitch);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const &imageDrmFormatModifierExplicitCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const &imageDrmFormatModifierListCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierListCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierListCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const &imageDrmFormatModifierPropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const &imageFormatListCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatListCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatListCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatListCreateInfo.viewFormatCount);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatListCreateInfo.pViewFormats);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageFormatProperties2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const &imageFormatProperties2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatProperties2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatProperties2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageFormatProperties2.imageFormatProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryBarrier>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const &imageMemoryBarrier) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.srcAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.dstAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.oldLayout);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.newLayout);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.srcQueueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.dstQueueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.image);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryBarrier.subresourceRange);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const &imageMemoryRequirementsInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryRequirementsInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryRequirementsInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageMemoryRequirementsInfo2.image);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const &imagePipeSurfaceCreateInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imagePipeSurfaceCreateInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imagePipeSurfaceCreateInfoFUCHSIA.flags);
		VULKAN_HPP_HASH_COMBINE(seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const &imagePlaneMemoryRequirementsInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imagePlaneMemoryRequirementsInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imagePlaneMemoryRequirementsInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imagePlaneMemoryRequirementsInfo.planeAspect);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageResolve>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageResolve const &imageResolve) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve.srcSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve.srcOffset);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve.dstSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve.dstOffset);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve.extent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageResolve2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageResolve2 const &imageResolve2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve2.srcSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve2.srcOffset);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve2.dstSubresource);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve2.dstOffset);
		VULKAN_HPP_HASH_COMBINE(seed, imageResolve2.extent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const &imageSparseMemoryRequirementsInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageSparseMemoryRequirementsInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageSparseMemoryRequirementsInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageSparseMemoryRequirementsInfo2.image);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const &imageStencilUsageCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageStencilUsageCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageStencilUsageCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageStencilUsageCreateInfo.stencilUsage);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const &imageSwapchainCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageSwapchainCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageSwapchainCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageSwapchainCreateInfoKHR.swapchain);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const &imageViewASTCDecodeModeEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageViewASTCDecodeModeEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewASTCDecodeModeEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewASTCDecodeModeEXT.decodeMode);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const &imageViewAddressPropertiesNVX) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageViewAddressPropertiesNVX.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewAddressPropertiesNVX.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewAddressPropertiesNVX.deviceAddress);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewAddressPropertiesNVX.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const &imageViewCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageViewCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewCreateInfo.image);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewCreateInfo.viewType);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewCreateInfo.format);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewCreateInfo.components);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewCreateInfo.subresourceRange);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const &imageViewHandleInfoNVX) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageViewHandleInfoNVX.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewHandleInfoNVX.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewHandleInfoNVX.imageView);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewHandleInfoNVX.descriptorType);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewHandleInfoNVX.sampler);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const &imageViewMinLodCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageViewMinLodCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewMinLodCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewMinLodCreateInfoEXT.minLod);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const &imageViewUsageCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, imageViewUsageCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewUsageCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, imageViewUsageCreateInfo.usage);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const &importAndroidHardwareBufferInfoANDROID) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importAndroidHardwareBufferInfoANDROID.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importAndroidHardwareBufferInfoANDROID.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importAndroidHardwareBufferInfoANDROID.buffer);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const &importFenceFdInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importFenceFdInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceFdInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceFdInfoKHR.fence);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceFdInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceFdInfoKHR.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceFdInfoKHR.fd);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const &importFenceWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importFenceWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceWin32HandleInfoKHR.fence);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceWin32HandleInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceWin32HandleInfoKHR.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceWin32HandleInfoKHR.handle);
		VULKAN_HPP_HASH_COMBINE(seed, importFenceWin32HandleInfoKHR.name);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const &importMemoryBufferCollectionFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryBufferCollectionFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryBufferCollectionFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryBufferCollectionFUCHSIA.collection);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryBufferCollectionFUCHSIA.index);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const &importMemoryFdInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryFdInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryFdInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryFdInfoKHR.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryFdInfoKHR.fd);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const &importMemoryHostPointerInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryHostPointerInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryHostPointerInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryHostPointerInfoEXT.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryHostPointerInfoEXT.pHostPointer);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const &importMemoryWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoKHR.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoKHR.handle);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoKHR.name);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const &importMemoryWin32HandleInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoNV.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryWin32HandleInfoNV.handle);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const &importMemoryZirconHandleInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryZirconHandleInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryZirconHandleInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryZirconHandleInfoFUCHSIA.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importMemoryZirconHandleInfoFUCHSIA.handle);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const &importSemaphoreFdInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreFdInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreFdInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreFdInfoKHR.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreFdInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreFdInfoKHR.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreFdInfoKHR.fd);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const &importSemaphoreWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreWin32HandleInfoKHR.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreWin32HandleInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreWin32HandleInfoKHR.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreWin32HandleInfoKHR.handle);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreWin32HandleInfoKHR.name);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const &importSemaphoreZirconHandleInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreZirconHandleInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreZirconHandleInfoFUCHSIA.flags);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType);
		VULKAN_HPP_HASH_COMBINE(seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const &indirectCommandsLayoutTokenNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.tokenType);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.stream);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.offset);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.vertexBindingUnit);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.vertexDynamicStride);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.pushconstantOffset);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.pushconstantSize);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.indirectStateFlags);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.indexTypeCount);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.pIndexTypes);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutTokenNV.pIndexTypeValues);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const &indirectCommandsLayoutCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutCreateInfoNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutCreateInfoNV.tokenCount);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutCreateInfoNV.pTokens);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutCreateInfoNV.streamCount);
		VULKAN_HPP_HASH_COMBINE(seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const &initializePerformanceApiInfoINTEL) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, initializePerformanceApiInfoINTEL.sType);
		VULKAN_HPP_HASH_COMBINE(seed, initializePerformanceApiInfoINTEL.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, initializePerformanceApiInfoINTEL.pUserData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const &inputAttachmentAspectReference) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, inputAttachmentAspectReference.subpass);
		VULKAN_HPP_HASH_COMBINE(seed, inputAttachmentAspectReference.inputAttachmentIndex);
		VULKAN_HPP_HASH_COMBINE(seed, inputAttachmentAspectReference.aspectMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::InstanceCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::InstanceCreateInfo const &instanceCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, instanceCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, instanceCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, instanceCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, instanceCreateInfo.pApplicationInfo);
		VULKAN_HPP_HASH_COMBINE(seed, instanceCreateInfo.enabledLayerCount);
		for(size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i)
		{
			for(const char *p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p)
			{
				VULKAN_HPP_HASH_COMBINE(seed, *p);
			}
		}
		VULKAN_HPP_HASH_COMBINE(seed, instanceCreateInfo.enabledExtensionCount);
		for(size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i)
		{
			for(const char *p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p)
			{
				VULKAN_HPP_HASH_COMBINE(seed, *p);
			}
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::LayerProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::LayerProperties const &layerProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		for(size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, layerProperties.layerName[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, layerProperties.specVersion);
		VULKAN_HPP_HASH_COMBINE(seed, layerProperties.implementationVersion);
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, layerProperties.description[i]);
		}
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_MACOS_MVK)
template<>
struct hash<VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const &macOSSurfaceCreateInfoMVK) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, macOSSurfaceCreateInfoMVK.sType);
		VULKAN_HPP_HASH_COMBINE(seed, macOSSurfaceCreateInfoMVK.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, macOSSurfaceCreateInfoMVK.flags);
		VULKAN_HPP_HASH_COMBINE(seed, macOSSurfaceCreateInfoMVK.pView);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_MACOS_MVK*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::MappedMemoryRange>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MappedMemoryRange const &mappedMemoryRange) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, mappedMemoryRange.sType);
		VULKAN_HPP_HASH_COMBINE(seed, mappedMemoryRange.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, mappedMemoryRange.memory);
		VULKAN_HPP_HASH_COMBINE(seed, mappedMemoryRange.offset);
		VULKAN_HPP_HASH_COMBINE(seed, mappedMemoryRange.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const &memoryAllocateFlagsInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryAllocateFlagsInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryAllocateFlagsInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryAllocateFlagsInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, memoryAllocateFlagsInfo.deviceMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryAllocateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const &memoryAllocateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryAllocateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryAllocateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryAllocateInfo.allocationSize);
		VULKAN_HPP_HASH_COMBINE(seed, memoryAllocateInfo.memoryTypeIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryBarrier>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryBarrier const &memoryBarrier) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier.srcAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, memoryBarrier.dstAccessMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const &memoryDedicatedAllocateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryDedicatedAllocateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryDedicatedAllocateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryDedicatedAllocateInfo.image);
		VULKAN_HPP_HASH_COMBINE(seed, memoryDedicatedAllocateInfo.buffer);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const &memoryDedicatedRequirements) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryDedicatedRequirements.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryDedicatedRequirements.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryDedicatedRequirements.prefersDedicatedAllocation);
		VULKAN_HPP_HASH_COMBINE(seed, memoryDedicatedRequirements.requiresDedicatedAllocation);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const &memoryFdPropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryFdPropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryFdPropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryFdPropertiesKHR.memoryTypeBits);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_ANDROID_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const &memoryGetAndroidHardwareBufferInfoANDROID) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetAndroidHardwareBufferInfoANDROID.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetAndroidHardwareBufferInfoANDROID.memory);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_ANDROID_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const &memoryGetFdInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetFdInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetFdInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetFdInfoKHR.memory);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetFdInfoKHR.handleType);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const &memoryGetRemoteAddressInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetRemoteAddressInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetRemoteAddressInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetRemoteAddressInfoNV.memory);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetRemoteAddressInfoNV.handleType);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const &memoryGetWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetWin32HandleInfoKHR.memory);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetWin32HandleInfoKHR.handleType);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const &memoryGetZirconHandleInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetZirconHandleInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetZirconHandleInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetZirconHandleInfoFUCHSIA.memory);
		VULKAN_HPP_HASH_COMBINE(seed, memoryGetZirconHandleInfoFUCHSIA.handleType);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryHeap>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryHeap const &memoryHeap) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryHeap.size);
		VULKAN_HPP_HASH_COMBINE(seed, memoryHeap.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const &memoryHostPointerPropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryHostPointerPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryHostPointerPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryHostPointerPropertiesEXT.memoryTypeBits);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const &memoryOpaqueCaptureAddressAllocateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryOpaqueCaptureAddressAllocateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryOpaqueCaptureAddressAllocateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const &memoryPriorityAllocateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryPriorityAllocateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryPriorityAllocateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryPriorityAllocateInfoEXT.priority);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryRequirements const &memoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryRequirements.size);
		VULKAN_HPP_HASH_COMBINE(seed, memoryRequirements.alignment);
		VULKAN_HPP_HASH_COMBINE(seed, memoryRequirements.memoryTypeBits);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryRequirements2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryRequirements2 const &memoryRequirements2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryRequirements2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryRequirements2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryRequirements2.memoryRequirements);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryType>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryType const &memoryType) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryType.propertyFlags);
		VULKAN_HPP_HASH_COMBINE(seed, memoryType.heapIndex);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const &memoryWin32HandlePropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryWin32HandlePropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryWin32HandlePropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryWin32HandlePropertiesKHR.memoryTypeBits);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const &memoryZirconHandlePropertiesFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, memoryZirconHandlePropertiesFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, memoryZirconHandlePropertiesFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

#	if defined(VK_USE_PLATFORM_METAL_EXT)
template<>
struct hash<VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const &metalSurfaceCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, metalSurfaceCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, metalSurfaceCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, metalSurfaceCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, metalSurfaceCreateInfoEXT.pLayer);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_METAL_EXT*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const &multiDrawIndexedInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, multiDrawIndexedInfoEXT.firstIndex);
		VULKAN_HPP_HASH_COMBINE(seed, multiDrawIndexedInfoEXT.indexCount);
		VULKAN_HPP_HASH_COMBINE(seed, multiDrawIndexedInfoEXT.vertexOffset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const &multiDrawInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, multiDrawInfoEXT.firstVertex);
		VULKAN_HPP_HASH_COMBINE(seed, multiDrawInfoEXT.vertexCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const &multisamplePropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, multisamplePropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, multisamplePropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, multisamplePropertiesEXT.maxSampleLocationGridSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const &multiviewPerViewAttributesInfoNVX) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, multiviewPerViewAttributesInfoNVX.sType);
		VULKAN_HPP_HASH_COMBINE(seed, multiviewPerViewAttributesInfoNVX.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, multiviewPerViewAttributesInfoNVX.perViewAttributes);
		VULKAN_HPP_HASH_COMBINE(seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListVALVE const &mutableDescriptorTypeListVALVE) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, mutableDescriptorTypeListVALVE.descriptorTypeCount);
		VULKAN_HPP_HASH_COMBINE(seed, mutableDescriptorTypeListVALVE.pDescriptorTypes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoVALVE const &mutableDescriptorTypeCreateInfoVALVE) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, mutableDescriptorTypeCreateInfoVALVE.sType);
		VULKAN_HPP_HASH_COMBINE(seed, mutableDescriptorTypeCreateInfoVALVE.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, mutableDescriptorTypeCreateInfoVALVE.mutableDescriptorTypeListCount);
		VULKAN_HPP_HASH_COMBINE(seed, mutableDescriptorTypeCreateInfoVALVE.pMutableDescriptorTypeLists);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const &pastPresentationTimingGOOGLE) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pastPresentationTimingGOOGLE.presentID);
		VULKAN_HPP_HASH_COMBINE(seed, pastPresentationTimingGOOGLE.desiredPresentTime);
		VULKAN_HPP_HASH_COMBINE(seed, pastPresentationTimingGOOGLE.actualPresentTime);
		VULKAN_HPP_HASH_COMBINE(seed, pastPresentationTimingGOOGLE.earliestPresentTime);
		VULKAN_HPP_HASH_COMBINE(seed, pastPresentationTimingGOOGLE.presentMargin);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const &performanceConfigurationAcquireInfoINTEL) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, performanceConfigurationAcquireInfoINTEL.sType);
		VULKAN_HPP_HASH_COMBINE(seed, performanceConfigurationAcquireInfoINTEL.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, performanceConfigurationAcquireInfoINTEL.type);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const &performanceCounterDescriptionKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, performanceCounterDescriptionKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, performanceCounterDescriptionKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, performanceCounterDescriptionKHR.flags);
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, performanceCounterDescriptionKHR.name[i]);
		}
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, performanceCounterDescriptionKHR.category[i]);
		}
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, performanceCounterDescriptionKHR.description[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceCounterKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const &performanceCounterKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, performanceCounterKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, performanceCounterKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, performanceCounterKHR.unit);
		VULKAN_HPP_HASH_COMBINE(seed, performanceCounterKHR.scope);
		VULKAN_HPP_HASH_COMBINE(seed, performanceCounterKHR.storage);
		for(size_t i = 0; i < VK_UUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, performanceCounterKHR.uuid[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const &performanceMarkerInfoINTEL) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, performanceMarkerInfoINTEL.sType);
		VULKAN_HPP_HASH_COMBINE(seed, performanceMarkerInfoINTEL.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, performanceMarkerInfoINTEL.marker);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const &performanceOverrideInfoINTEL) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, performanceOverrideInfoINTEL.sType);
		VULKAN_HPP_HASH_COMBINE(seed, performanceOverrideInfoINTEL.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, performanceOverrideInfoINTEL.type);
		VULKAN_HPP_HASH_COMBINE(seed, performanceOverrideInfoINTEL.enable);
		VULKAN_HPP_HASH_COMBINE(seed, performanceOverrideInfoINTEL.parameter);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const &performanceQuerySubmitInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, performanceQuerySubmitInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, performanceQuerySubmitInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, performanceQuerySubmitInfoKHR.counterPassIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const &performanceStreamMarkerInfoINTEL) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, performanceStreamMarkerInfoINTEL.sType);
		VULKAN_HPP_HASH_COMBINE(seed, performanceStreamMarkerInfoINTEL.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, performanceStreamMarkerInfoINTEL.marker);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const &physicalDevice16BitStorageFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice16BitStorageFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice16BitStorageFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice16BitStorageFeatures.storagePushConstant16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice16BitStorageFeatures.storageInputOutput16);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const &physicalDevice4444FormatsFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice4444FormatsFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice4444FormatsFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const &physicalDevice8BitStorageFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice8BitStorageFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice8BitStorageFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevice8BitStorageFeatures.storagePushConstant8);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const &physicalDeviceASTCDecodeFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceASTCDecodeFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceASTCDecodeFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const &physicalDeviceAccelerationStructureFeaturesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructureFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const &physicalDeviceAccelerationStructurePropertiesKHR)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const &physicalDeviceBlendOperationAdvancedFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const &physicalDeviceBlendOperationAdvancedPropertiesEXT)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const &physicalDeviceBorderColorSwizzleFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const &physicalDeviceBufferDeviceAddressFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const &physicalDeviceBufferDeviceAddressFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const &physicalDeviceCoherentMemoryFeaturesAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCoherentMemoryFeaturesAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const &physicalDeviceColorWriteEnableFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceColorWriteEnableFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV const &physicalDeviceComputeShaderDerivativesFeaturesNV)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceComputeShaderDerivativesFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceComputeShaderDerivativesFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupQuads);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceComputeShaderDerivativesFeaturesNV.computeDerivativeGroupLinear);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const &physicalDeviceConditionalRenderingFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConditionalRenderingFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const &
	                           physicalDeviceConservativeRasterizationPropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const &physicalDeviceCooperativeMatrixFeaturesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCooperativeMatrixFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const &physicalDeviceCooperativeMatrixPropertiesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCooperativeMatrixPropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const &physicalDeviceCornerSampledImageFeaturesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCornerSampledImageFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCornerSampledImageFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const &physicalDeviceCoverageReductionModeFeaturesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCoverageReductionModeFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const &physicalDeviceCustomBorderColorFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCustomBorderColorFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const &physicalDeviceCustomBorderColorPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCustomBorderColorPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &
	                           physicalDeviceDedicatedAllocationImageAliasingFeaturesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const &physicalDeviceDepthClipControlFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthClipControlFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthClipControlFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const &physicalDeviceDepthClipEnableFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthClipEnableFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const &physicalDeviceDepthStencilResolveProperties) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthStencilResolveProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthStencilResolveProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDepthStencilResolveProperties.independentResolve);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const &physicalDeviceDescriptorIndexingFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const &physicalDeviceDescriptorIndexingProperties) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const &physicalDeviceDescriptorSetHostMappingFeaturesVALVE) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &physicalDeviceDeviceGeneratedCommandsFeaturesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &physicalDeviceDeviceGeneratedCommandsPropertiesNV)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const &physicalDeviceDeviceMemoryReportFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const &physicalDeviceDiagnosticsConfigFeaturesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const &physicalDeviceDiscardRectanglePropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDiscardRectanglePropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const &physicalDeviceDriverProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDriverProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDriverProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDriverProperties.driverID);
		for(size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDriverProperties.driverName[i]);
		}
		for(size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDriverProperties.driverInfo[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDriverProperties.conformanceVersion);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const &physicalDeviceDrmPropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDrmPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDrmPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDrmPropertiesEXT.hasPrimary);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDrmPropertiesEXT.hasRender);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDrmPropertiesEXT.primaryMajor);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDrmPropertiesEXT.primaryMinor);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDrmPropertiesEXT.renderMajor);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDrmPropertiesEXT.renderMinor);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const &physicalDeviceDynamicRenderingFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDynamicRenderingFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDynamicRenderingFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const &physicalDeviceExclusiveScissorFeaturesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExclusiveScissorFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExclusiveScissorFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const &physicalDeviceExtendedDynamicState2FeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const &physicalDeviceExtendedDynamicStateFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const &physicalDeviceExternalBufferInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalBufferInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalBufferInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalBufferInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalBufferInfo.usage);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalBufferInfo.handleType);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const &physicalDeviceExternalFenceInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalFenceInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalFenceInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalFenceInfo.handleType);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const &physicalDeviceExternalImageFormatInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalImageFormatInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalImageFormatInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalImageFormatInfo.handleType);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const &physicalDeviceExternalMemoryHostPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const &physicalDeviceExternalMemoryRDMAFeaturesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const &physicalDeviceExternalSemaphoreInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalSemaphoreInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalSemaphoreInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceExternalSemaphoreInfo.handleType);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const &physicalDeviceFeatures2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFeatures2.features);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const &physicalDeviceFloatControlsProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.roundingModeIndependence);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const &physicalDeviceFragmentDensityMap2FeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const &physicalDeviceFragmentDensityMap2PropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const &physicalDeviceFragmentDensityMapFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM const &physicalDeviceFragmentDensityMapOffsetFeaturesQCOM) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapOffsetFeaturesQCOM.fragmentDensityMapOffset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM const &
	                           physicalDeviceFragmentDensityMapOffsetPropertiesQCOM) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapOffsetPropertiesQCOM.fragmentDensityOffsetGranularity);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const &physicalDeviceFragmentDensityMapPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesNV const &physicalDeviceFragmentShaderBarycentricFeaturesNV)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShaderBarycentricFeaturesNV.fragmentShaderBarycentric);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const &physicalDeviceFragmentShaderInterlockFeaturesEXT)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &physicalDeviceFragmentShadingRateEnumsFeaturesNV)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &physicalDeviceFragmentShadingRateEnumsPropertiesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const &physicalDeviceFragmentShadingRateFeaturesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const &physicalDeviceFragmentShadingRateKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateKHR.sampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRateKHR.fragmentSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const &physicalDeviceFragmentShadingRatePropertiesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR const &physicalDeviceGlobalPriorityQueryFeaturesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const &physicalDeviceGraphicsPipelineLibraryFeaturesEXT)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const &physicalDeviceGraphicsPipelineLibraryPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const &physicalDeviceGroupProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGroupProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGroupProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGroupProperties.physicalDeviceCount);
		for(size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGroupProperties.physicalDevices[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceGroupProperties.subsetAllocation);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const &physicalDeviceHostQueryResetFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceHostQueryResetFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceHostQueryResetFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceHostQueryResetFeatures.hostQueryReset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const &physicalDeviceIDProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIDProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIDProperties.pNext);
		for(size_t i = 0; i < VK_UUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIDProperties.deviceUUID[i]);
		}
		for(size_t i = 0; i < VK_UUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIDProperties.driverUUID[i]);
		}
		for(size_t i = 0; i < VK_LUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIDProperties.deviceLUID[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIDProperties.deviceNodeMask);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIDProperties.deviceLUIDValid);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const &physicalDeviceImage2DViewOf3DFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const &physicalDeviceImageDrmFormatModifierInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const &physicalDeviceImageFormatInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageFormatInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageFormatInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageFormatInfo2.format);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageFormatInfo2.type);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageFormatInfo2.tiling);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageFormatInfo2.usage);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageFormatInfo2.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const &physicalDeviceImageRobustnessFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageRobustnessFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageRobustnessFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageRobustnessFeatures.robustImageAccess);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const &physicalDeviceImageViewImageFormatInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageViewImageFormatInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageViewImageFormatInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const &physicalDeviceImageViewMinLodFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageViewMinLodFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const &physicalDeviceImagelessFramebufferFeatures) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImagelessFramebufferFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImagelessFramebufferFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT const &physicalDeviceIndexTypeUint8FeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIndexTypeUint8FeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIndexTypeUint8FeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const &physicalDeviceInheritedViewportScissorFeaturesNV)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const &physicalDeviceInlineUniformBlockFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const &physicalDeviceInlineUniformBlockProperties) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const &physicalDeviceInvocationMaskFeaturesHUAWEI) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const &physicalDeviceLimits) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxImageDimension1D);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxImageDimension2D);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxImageDimension3D);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxImageDimensionCube);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxImageArrayLayers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTexelBufferElements);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxUniformBufferRange);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxStorageBufferRange);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxPushConstantsSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxMemoryAllocationCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxSamplerAllocationCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.bufferImageGranularity);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.sparseAddressSpaceSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxBoundDescriptorSets);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxPerStageDescriptorSamplers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxPerStageResources);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDescriptorSetSamplers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDescriptorSetSampledImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDescriptorSetStorageImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDescriptorSetInputAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxVertexInputAttributes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxVertexInputBindings);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxVertexInputAttributeOffset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxVertexInputBindingStride);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxVertexOutputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTessellationGenerationLevel);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTessellationPatchSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxGeometryShaderInvocations);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxGeometryInputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxGeometryOutputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxGeometryOutputVertices);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxGeometryTotalOutputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxFragmentInputComponents);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxFragmentOutputAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxFragmentDualSrcAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxFragmentCombinedOutputResources);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxComputeSharedMemorySize);
		for(size_t i = 0; i < 3; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxComputeWorkGroupCount[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxComputeWorkGroupInvocations);
		for(size_t i = 0; i < 3; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxComputeWorkGroupSize[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.subPixelPrecisionBits);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.subTexelPrecisionBits);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.mipmapPrecisionBits);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDrawIndexedIndexValue);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxDrawIndirectCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxSamplerLodBias);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxSamplerAnisotropy);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxViewports);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxViewportDimensions[i]);
		}
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.viewportBoundsRange[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.viewportSubPixelBits);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.minMemoryMapAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.minTexelBufferOffsetAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.minUniformBufferOffsetAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.minStorageBufferOffsetAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.minTexelOffset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTexelOffset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.minTexelGatherOffset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxTexelGatherOffset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.minInterpolationOffset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxInterpolationOffset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.subPixelInterpolationOffsetBits);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxFramebufferWidth);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxFramebufferHeight);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxFramebufferLayers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.framebufferColorSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.framebufferDepthSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.framebufferStencilSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxColorAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.sampledImageColorSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.sampledImageIntegerSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.sampledImageDepthSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.sampledImageStencilSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.storageImageSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxSampleMaskWords);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.timestampComputeAndGraphics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.timestampPeriod);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxClipDistances);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxCullDistances);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.maxCombinedClipAndCullDistances);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.discreteQueuePriorities);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.pointSizeRange[i]);
		}
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.lineWidthRange[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.pointSizeGranularity);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.lineWidthGranularity);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.strictLines);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.standardSampleLocations);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLimits.nonCoherentAtomSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT const &physicalDeviceLineRasterizationFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationFeaturesEXT.rectangularLines);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationFeaturesEXT.smoothLines);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT const &physicalDeviceLineRasterizationPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLineRasterizationPropertiesEXT.lineSubPixelPrecisionBits);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const &physicalDeviceLinearColorAttachmentFeaturesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const &physicalDeviceMaintenance3Properties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance3Properties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance3Properties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const &physicalDeviceMaintenance4Features) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance4Features.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance4Features.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance4Features.maintenance4);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const &physicalDeviceMaintenance4Properties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance4Properties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance4Properties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMaintenance4Properties.maxBufferSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const &physicalDeviceMemoryBudgetPropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryBudgetPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext);
		for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i]);
		}
		for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const &physicalDeviceMemoryPriorityFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryPriorityFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const &physicalDeviceMemoryProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryProperties.memoryTypeCount);
		for(size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryProperties.memoryTypes[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryProperties.memoryHeapCount);
		for(size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryProperties.memoryHeaps[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const &physicalDeviceMemoryProperties2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryProperties2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryProperties2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMemoryProperties2.memoryProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const &physicalDeviceMeshShaderFeaturesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderFeaturesNV.taskShader);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderFeaturesNV.meshShader);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const &physicalDeviceMeshShaderPropertiesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations);
		for(size_t i = 0; i < 3; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations);
		for(size_t i = 0; i < 3; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const &physicalDeviceMultiDrawFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiDrawFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiDrawFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const &physicalDeviceMultiDrawPropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiDrawPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiDrawPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const &physicalDeviceMultiviewFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewFeatures.multiview);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &
	                           physicalDeviceMultiviewPerViewAttributesPropertiesNVX) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const &physicalDeviceMultiviewProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesVALVE const &physicalDeviceMutableDescriptorTypeFeaturesVALVE)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceMutableDescriptorTypeFeaturesVALVE.mutableDescriptorType);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const &physicalDevicePCIBusInfoPropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePCIBusInfoPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePCIBusInfoPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &physicalDevicePageableDeviceLocalMemoryFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const &physicalDevicePerformanceQueryFeaturesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePerformanceQueryFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePerformanceQueryFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const &physicalDevicePerformanceQueryPropertiesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePerformanceQueryPropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePerformanceQueryPropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const &physicalDevicePipelineCreationCacheControlFeatures) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePipelineCreationCacheControlFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePipelineCreationCacheControlFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &
	                           physicalDevicePipelineExecutablePropertiesFeaturesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const &physicalDevicePointClippingProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePointClippingProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePointClippingProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePointClippingProperties.pointClippingBehavior);
		return seed;
	}
};

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const &physicalDevicePortabilitySubsetFeaturesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.events);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const &physicalDevicePortabilitySubsetPropertiesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetPropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const &physicalDevicePresentIdFeaturesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePresentIdFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePresentIdFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePresentIdFeaturesKHR.presentId);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const &physicalDevicePresentWaitFeaturesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePresentWaitFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePresentWaitFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePresentWaitFeaturesKHR.presentWait);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &
	                           physicalDevicePrimitiveTopologyListRestartFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const &physicalDevicePrimitivesGeneratedQueryFeaturesEXT)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const &physicalDevicePrivateDataFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrivateDataFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrivateDataFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePrivateDataFeatures.privateData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const &physicalDeviceSparseProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseProperties.residencyAlignedMipSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseProperties.residencyNonResidentStrict);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const &physicalDeviceProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.apiVersion);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.driverVersion);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.vendorID);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.deviceID);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.deviceType);
		for(size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.deviceName[i]);
		}
		for(size_t i = 0; i < VK_UUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.pipelineCacheUUID[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.limits);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties.sparseProperties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const &physicalDeviceProperties2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProperties2.properties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const &physicalDeviceProtectedMemoryFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProtectedMemoryFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProtectedMemoryFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProtectedMemoryFeatures.protectedMemory);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const &physicalDeviceProtectedMemoryProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProtectedMemoryProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProtectedMemoryProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProtectedMemoryProperties.protectedNoFault);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const &physicalDeviceProvokingVertexFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProvokingVertexFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProvokingVertexFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const &physicalDeviceProvokingVertexPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProvokingVertexPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProvokingVertexPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR const &physicalDevicePushDescriptorPropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePushDescriptorPropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePushDescriptorPropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDevicePushDescriptorPropertiesKHR.maxPushDescriptors);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const &physicalDeviceRGBA10X6FormatsFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM const &
	                           physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderColorAttachmentAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderDepthAttachmentAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesARM.rasterizationOrderStencilAttachmentAccess);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const &physicalDeviceRayQueryFeaturesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayQueryFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayQueryFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayQueryFeaturesKHR.rayQuery);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const &physicalDeviceRayTracingMotionBlurFeaturesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const &physicalDeviceRayTracingPipelineFeaturesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const &physicalDeviceRayTracingPipelinePropertiesKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const &physicalDeviceRayTracingPropertiesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const &physicalDeviceRepresentativeFragmentTestFeaturesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT const &physicalDeviceRobustness2FeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2FeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2FeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2FeaturesEXT.robustBufferAccess2);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2FeaturesEXT.robustImageAccess2);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2FeaturesEXT.nullDescriptor);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT const &physicalDeviceRobustness2PropertiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2PropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2PropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2PropertiesEXT.robustStorageBufferAccessSizeAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceRobustness2PropertiesEXT.robustUniformBufferAccessSizeAlignment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const &physicalDeviceSampleLocationsPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSampleLocationsPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSampleLocationsPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const &physicalDeviceSamplerFilterMinmaxProperties) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSamplerFilterMinmaxProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSamplerFilterMinmaxProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const &physicalDeviceSamplerYcbcrConversionFeatures) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSamplerYcbcrConversionFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const &physicalDeviceScalarBlockLayoutFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceScalarBlockLayoutFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceScalarBlockLayoutFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const &physicalDeviceSeparateDepthStencilLayoutsFeatures)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const &physicalDeviceShaderAtomicFloat2FeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const &physicalDeviceShaderAtomicFloatFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const &physicalDeviceShaderAtomicInt64Features) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicInt64Features.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicInt64Features.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const &physicalDeviceShaderClockFeaturesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderClockFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderClockFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const &physicalDeviceShaderCoreProperties2AMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCoreProperties2AMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCoreProperties2AMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const &physicalDeviceShaderCorePropertiesAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const &
	                           physicalDeviceShaderDemoteToHelperInvocationFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const &physicalDeviceShaderDrawParametersFeatures) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderDrawParametersFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderDrawParametersFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const &physicalDeviceShaderFloat16Int8Features) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderFloat16Int8Features.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderFloat16Int8Features.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderFloat16Int8Features.shaderInt8);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &physicalDeviceShaderImageAtomicInt64FeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const &physicalDeviceShaderImageFootprintFeaturesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderImageFootprintFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const &physicalDeviceShaderIntegerDotProductFeatures) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const &physicalDeviceShaderIntegerDotProductProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed,
		                        physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &physicalDeviceShaderIntegerFunctions2FeaturesINTEL) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const &physicalDeviceShaderSMBuiltinsFeaturesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const &physicalDeviceShaderSMBuiltinsPropertiesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const &physicalDeviceShaderSubgroupExtendedTypesFeatures)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &
	                           physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const &physicalDeviceShaderTerminateInvocationFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderTerminateInvocationFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderTerminateInvocationFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const &physicalDeviceShadingRateImageFeaturesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImageFeaturesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImageFeaturesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const &physicalDeviceShadingRateImagePropertiesNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImagePropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImagePropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const &physicalDeviceSparseImageFormatInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseImageFormatInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseImageFormatInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseImageFormatInfo2.format);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseImageFormatInfo2.type);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseImageFormatInfo2.samples);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseImageFormatInfo2.usage);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSparseImageFormatInfo2.tiling);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const &physicalDeviceSubgroupProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupProperties.subgroupSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupProperties.supportedStages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupProperties.supportedOperations);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const &physicalDeviceSubgroupSizeControlFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const &physicalDeviceSubgroupSizeControlProperties) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const &physicalDeviceSubpassShadingFeaturesHUAWEI) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const &physicalDeviceSubpassShadingPropertiesHUAWEI) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const &physicalDeviceSurfaceInfo2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSurfaceInfo2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSurfaceInfo2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSurfaceInfo2KHR.surface);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const &physicalDeviceSynchronization2Features) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSynchronization2Features.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSynchronization2Features.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceSynchronization2Features.synchronization2);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const &physicalDeviceTexelBufferAlignmentFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const &physicalDeviceTexelBufferAlignmentProperties) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const &physicalDeviceTextureCompressionASTCHDRFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const &physicalDeviceTimelineSemaphoreFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTimelineSemaphoreFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTimelineSemaphoreFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const &physicalDeviceTimelineSemaphoreProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTimelineSemaphoreProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTimelineSemaphoreProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const &physicalDeviceToolProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceToolProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceToolProperties.pNext);
		for(size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceToolProperties.name[i]);
		}
		for(size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceToolProperties.version[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceToolProperties.purposes);
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceToolProperties.description[i]);
		}
		for(size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceToolProperties.layer[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const &physicalDeviceTransformFeedbackFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const &physicalDeviceTransformFeedbackPropertiesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const &physicalDeviceUniformBufferStandardLayoutFeatures)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const &physicalDeviceVariablePointersFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVariablePointersFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVariablePointersFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVariablePointersFeatures.variablePointers);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT const &physicalDeviceVertexAttributeDivisorFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateZeroDivisor);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const &physicalDeviceVertexAttributeDivisorPropertiesEXT)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const &physicalDeviceVertexInputDynamicStateFeaturesEXT)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState);
		return seed;
	}
};

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoProfileKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoProfileKHR const &videoProfileKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoProfileKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoProfileKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoProfileKHR.videoCodecOperation);
		VULKAN_HPP_HASH_COMBINE(seed, videoProfileKHR.chromaSubsampling);
		VULKAN_HPP_HASH_COMBINE(seed, videoProfileKHR.lumaBitDepth);
		VULKAN_HPP_HASH_COMBINE(seed, videoProfileKHR.chromaBitDepth);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoProfilesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoProfilesKHR const &videoProfilesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoProfilesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoProfilesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoProfilesKHR.profileCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoProfilesKHR.pProfiles);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const &physicalDeviceVideoFormatInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVideoFormatInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVideoFormatInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVideoFormatInfoKHR.imageUsage);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVideoFormatInfoKHR.pVideoProfiles);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const &physicalDeviceVulkan11Features) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.storagePushConstant16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.storageInputOutput16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.multiview);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.multiviewGeometryShader);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.multiviewTessellationShader);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.variablePointers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.protectedMemory);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.samplerYcbcrConversion);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Features.shaderDrawParameters);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const &physicalDeviceVulkan11Properties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.pNext);
		for(size_t i = 0; i < VK_UUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.deviceUUID[i]);
		}
		for(size_t i = 0; i < VK_UUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.driverUUID[i]);
		}
		for(size_t i = 0; i < VK_LUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.deviceLUID[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.deviceNodeMask);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.deviceLUIDValid);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.subgroupSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.subgroupSupportedStages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.pointClippingBehavior);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.protectedNoFault);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const &physicalDeviceVulkan12Features) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.drawIndirectCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.storagePushConstant8);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderInt8);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.runtimeDescriptorArray);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.samplerFilterMinmax);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.scalarBlockLayout);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.imagelessFramebuffer);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.hostQueryReset);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.timelineSemaphore);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.bufferDeviceAddress);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.vulkanMemoryModel);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.shaderOutputLayer);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const &physicalDeviceVulkan12Properties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.driverID);
		for(size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.driverName[i]);
		}
		for(size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.driverInfo[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.conformanceVersion);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.roundingModeIndependence);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.independentResolveNone);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.independentResolve);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const &physicalDeviceVulkan13Features) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.robustImageAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.inlineUniformBlock);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.privateData);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.shaderTerminateInvocation);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.subgroupSizeControl);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.computeFullSubgroups);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.synchronization2);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.dynamicRendering);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Features.maintenance4);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const &physicalDeviceVulkan13Properties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.minSubgroupSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxSubgroupSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkan13Properties.maxBufferSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const &physicalDeviceVulkanMemoryModelFeatures) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkanMemoryModelFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkanMemoryModelFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &
	                           physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &physicalDeviceYcbcr2Plane444FormatsFeaturesEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const &physicalDeviceYcbcrImageArraysFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const &physicalDeviceZeroInitializeWorkgroupMemoryFeatures) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const &pipelineCacheCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheCreateInfo.initialDataSize);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheCreateInfo.pInitialData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const &pipelineCacheHeaderVersionOne) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheHeaderVersionOne.headerSize);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheHeaderVersionOne.headerVersion);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheHeaderVersionOne.vendorID);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheHeaderVersionOne.deviceID);
		for(size_t i = 0; i < VK_UUID_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const &pipelineColorBlendAdvancedStateCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const &pipelineColorWriteCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorWriteCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorWriteCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorWriteCreateInfoEXT.attachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const &pipelineCompilerControlCreateInfoAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCompilerControlCreateInfoAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCompilerControlCreateInfoAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const &pipelineCoverageModulationStateCreateInfoNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageModulationStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageModulationStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageModulationStateCreateInfoNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const &pipelineCoverageReductionStateCreateInfoNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageReductionStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageReductionStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageReductionStateCreateInfoNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const &pipelineCoverageToColorStateCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageToColorStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageToColorStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageToColorStateCreateInfoNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedback>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const &pipelineCreationFeedback) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCreationFeedback.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCreationFeedback.duration);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const &pipelineCreationFeedbackCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCreationFeedbackCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCreationFeedbackCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const &pipelineDiscardRectangleStateCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDiscardRectangleStateCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDiscardRectangleStateCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const &pipelineExecutableInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInfoKHR.pipeline);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInfoKHR.executableIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const &pipelineExecutableInternalRepresentationKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInternalRepresentationKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInternalRepresentationKHR.pNext);
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInternalRepresentationKHR.name[i]);
		}
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInternalRepresentationKHR.description[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInternalRepresentationKHR.isText);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInternalRepresentationKHR.dataSize);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutableInternalRepresentationKHR.pData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const &pipelineExecutablePropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutablePropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutablePropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutablePropertiesKHR.stages);
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutablePropertiesKHR.name[i]);
		}
		for(size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutablePropertiesKHR.description[i]);
		}
		VULKAN_HPP_HASH_COMBINE(seed, pipelineExecutablePropertiesKHR.subgroupSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const &pipelineFragmentShadingRateEnumStateCreateInfoNV)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const &pipelineFragmentShadingRateStateCreateInfoKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize);
		for(size_t i = 0; i < 2; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineInfoKHR const &pipelineInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineInfoKHR.pipeline);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PushConstantRange>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PushConstantRange const &pushConstantRange) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pushConstantRange.stageFlags);
		VULKAN_HPP_HASH_COMBINE(seed, pushConstantRange.offset);
		VULKAN_HPP_HASH_COMBINE(seed, pushConstantRange.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const &pipelineLayoutCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLayoutCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLayoutCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLayoutCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLayoutCreateInfo.setLayoutCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLayoutCreateInfo.pSetLayouts);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLayoutCreateInfo.pushConstantRangeCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLayoutCreateInfo.pPushConstantRanges);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const &pipelineLibraryCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLibraryCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLibraryCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLibraryCreateInfoKHR.libraryCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineLibraryCreateInfoKHR.pLibraries);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const &pipelineRasterizationConservativeStateCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const &pipelineRasterizationDepthClipStateCreateInfoEXT)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT const &pipelineRasterizationLineStateCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationLineStateCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationLineStateCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationLineStateCreateInfoEXT.lineRasterizationMode);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationLineStateCreateInfoEXT.stippledLineEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationLineStateCreateInfoEXT.lineStippleFactor);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationLineStateCreateInfoEXT.lineStipplePattern);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const &
	                           pipelineRasterizationProvokingVertexStateCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const &pipelineRasterizationStateRasterizationOrderAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateRasterizationOrderAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateRasterizationOrderAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const &pipelineRasterizationStateStreamCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateStreamCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateStreamCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const &pipelineRenderingCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRenderingCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRenderingCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRenderingCreateInfo.viewMask);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRenderingCreateInfo.colorAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRenderingCreateInfo.pColorAttachmentFormats);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRenderingCreateInfo.depthAttachmentFormat);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRenderingCreateInfo.stencilAttachmentFormat);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const &pipelineRepresentativeFragmentTestStateCreateInfoNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const &pipelineSampleLocationsStateCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineSampleLocationsStateCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineSampleLocationsStateCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const &pipelineShaderStageRequiredSubgroupSizeCreateInfo)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const &pipelineTessellationDomainOriginStateCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineTessellationDomainOriginStateCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineTessellationDomainOriginStateCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT const &vertexInputBindingDivisorDescriptionEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDivisorDescriptionEXT.binding);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDivisorDescriptionEXT.divisor);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT const &pipelineVertexInputDivisorStateCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputDivisorStateCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputDivisorStateCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputDivisorStateCreateInfoEXT.vertexBindingDivisorCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineVertexInputDivisorStateCreateInfoEXT.pVertexBindingDivisors);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const &pipelineViewportCoarseSampleOrderStateCreateInfoNV) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const &pipelineViewportDepthClipControlCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportDepthClipControlCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const &pipelineViewportExclusiveScissorStateCreateInfoNV)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const &shadingRatePaletteNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, shadingRatePaletteNV.shadingRatePaletteEntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, shadingRatePaletteNV.pShadingRatePaletteEntries);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const &pipelineViewportShadingRateImageStateCreateInfoNV)
	    const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ViewportSwizzleNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const &viewportSwizzleNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, viewportSwizzleNV.x);
		VULKAN_HPP_HASH_COMBINE(seed, viewportSwizzleNV.y);
		VULKAN_HPP_HASH_COMBINE(seed, viewportSwizzleNV.z);
		VULKAN_HPP_HASH_COMBINE(seed, viewportSwizzleNV.w);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const &pipelineViewportSwizzleStateCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportSwizzleStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportSwizzleStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportSwizzleStateCreateInfoNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ViewportWScalingNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ViewportWScalingNV const &viewportWScalingNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, viewportWScalingNV.xcoeff);
		VULKAN_HPP_HASH_COMBINE(seed, viewportWScalingNV.ycoeff);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const &pipelineViewportWScalingStateCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportWScalingStateCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportWScalingStateCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount);
		VULKAN_HPP_HASH_COMBINE(seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_GGP)
template<>
struct hash<VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const &presentFrameTokenGGP) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, presentFrameTokenGGP.sType);
		VULKAN_HPP_HASH_COMBINE(seed, presentFrameTokenGGP.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, presentFrameTokenGGP.frameToken);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_GGP*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::PresentIdKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PresentIdKHR const &presentIdKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, presentIdKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, presentIdKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, presentIdKHR.swapchainCount);
		VULKAN_HPP_HASH_COMBINE(seed, presentIdKHR.pPresentIds);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PresentInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PresentInfoKHR const &presentInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, presentInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, presentInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, presentInfoKHR.waitSemaphoreCount);
		VULKAN_HPP_HASH_COMBINE(seed, presentInfoKHR.pWaitSemaphores);
		VULKAN_HPP_HASH_COMBINE(seed, presentInfoKHR.swapchainCount);
		VULKAN_HPP_HASH_COMBINE(seed, presentInfoKHR.pSwapchains);
		VULKAN_HPP_HASH_COMBINE(seed, presentInfoKHR.pImageIndices);
		VULKAN_HPP_HASH_COMBINE(seed, presentInfoKHR.pResults);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RectLayerKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RectLayerKHR const &rectLayerKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, rectLayerKHR.offset);
		VULKAN_HPP_HASH_COMBINE(seed, rectLayerKHR.extent);
		VULKAN_HPP_HASH_COMBINE(seed, rectLayerKHR.layer);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PresentRegionKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PresentRegionKHR const &presentRegionKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, presentRegionKHR.rectangleCount);
		VULKAN_HPP_HASH_COMBINE(seed, presentRegionKHR.pRectangles);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PresentRegionsKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PresentRegionsKHR const &presentRegionsKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, presentRegionsKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, presentRegionsKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, presentRegionsKHR.swapchainCount);
		VULKAN_HPP_HASH_COMBINE(seed, presentRegionsKHR.pRegions);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const &presentTimeGOOGLE) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, presentTimeGOOGLE.presentID);
		VULKAN_HPP_HASH_COMBINE(seed, presentTimeGOOGLE.desiredPresentTime);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const &presentTimesInfoGOOGLE) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, presentTimesInfoGOOGLE.sType);
		VULKAN_HPP_HASH_COMBINE(seed, presentTimesInfoGOOGLE.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, presentTimesInfoGOOGLE.swapchainCount);
		VULKAN_HPP_HASH_COMBINE(seed, presentTimesInfoGOOGLE.pTimes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const &privateDataSlotCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, privateDataSlotCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, privateDataSlotCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, privateDataSlotCreateInfo.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const &protectedSubmitInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, protectedSubmitInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, protectedSubmitInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, protectedSubmitInfo.protectedSubmit);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const &queryPoolCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolCreateInfo.queryType);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolCreateInfo.queryCount);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolCreateInfo.pipelineStatistics);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const &queryPoolPerformanceCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolPerformanceCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolPerformanceCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const &queryPoolPerformanceQueryCreateInfoINTEL) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolPerformanceQueryCreateInfoINTEL.sType);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const &queueFamilyCheckpointProperties2NV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyCheckpointProperties2NV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyCheckpointProperties2NV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const &queueFamilyCheckpointPropertiesNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyCheckpointPropertiesNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyCheckpointPropertiesNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR const &queueFamilyGlobalPriorityPropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyGlobalPriorityPropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyGlobalPriorityPropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyGlobalPriorityPropertiesKHR.priorityCount);
		for(size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, queueFamilyGlobalPriorityPropertiesKHR.priorities[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::QueueFamilyProperties const &queueFamilyProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyProperties.queueFlags);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyProperties.queueCount);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyProperties.timestampValidBits);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyProperties.minImageTransferGranularity);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyProperties2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const &queueFamilyProperties2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyProperties2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyProperties2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyProperties2.queueFamilyProperties);
		return seed;
	}
};

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusProperties2KHR const &queueFamilyQueryResultStatusProperties2KHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyQueryResultStatusProperties2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyQueryResultStatusProperties2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, queueFamilyQueryResultStatusProperties2KHR.supported);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const &rayTracingShaderGroupCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoKHR.type);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoKHR.generalShader);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const &rayTracingPipelineInterfaceCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineInterfaceCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const &rayTracingPipelineCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.stageCount);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.pStages);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.groupCount);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.pGroups);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.pDynamicState);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.layout);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const &rayTracingShaderGroupCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoNV.type);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoNV.generalShader);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoNV.closestHitShader);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoNV.anyHitShader);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingShaderGroupCreateInfoNV.intersectionShader);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const &rayTracingPipelineCreateInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.flags);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.stageCount);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.pStages);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.groupCount);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.pGroups);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.layout);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.basePipelineHandle);
		VULKAN_HPP_HASH_COMBINE(seed, rayTracingPipelineCreateInfoNV.basePipelineIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const &refreshCycleDurationGOOGLE) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, refreshCycleDurationGOOGLE.refreshDuration);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const &renderPassAttachmentBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassAttachmentBeginInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassAttachmentBeginInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassAttachmentBeginInfo.attachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassAttachmentBeginInfo.pAttachments);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassBeginInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const &renderPassBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassBeginInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassBeginInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassBeginInfo.renderPass);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassBeginInfo.framebuffer);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassBeginInfo.renderArea);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassBeginInfo.clearValueCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassBeginInfo.pClearValues);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubpassDescription const &subpassDescription) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.flags);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.pipelineBindPoint);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.inputAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.pInputAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.colorAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.pColorAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.pResolveAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.pDepthStencilAttachment);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.preserveAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription.pPreserveAttachments);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubpassDependency const &subpassDependency) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency.srcSubpass);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency.dstSubpass);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency.srcStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency.dstStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency.srcAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency.dstAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency.dependencyFlags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const &renderPassCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.attachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.pAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.subpassCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.pSubpasses);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.dependencyCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo.pDependencies);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassDescription2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubpassDescription2 const &subpassDescription2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.flags);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.pipelineBindPoint);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.viewMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.inputAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.pInputAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.colorAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.pColorAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.pResolveAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.pDepthStencilAttachment);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.preserveAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescription2.pPreserveAttachments);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassDependency2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubpassDependency2 const &subpassDependency2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.srcSubpass);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.dstSubpass);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.srcStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.dstStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.srcAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.dstAccessMask);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.dependencyFlags);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDependency2.viewOffset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const &renderPassCreateInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.flags);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.attachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.pAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.subpassCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.pSubpasses);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.dependencyCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.pDependencies);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.correlatedViewMaskCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassCreateInfo2.pCorrelatedViewMasks);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const &renderPassFragmentDensityMapCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassFragmentDensityMapCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassFragmentDensityMapCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const &renderPassInputAttachmentAspectCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassInputAttachmentAspectCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassInputAttachmentAspectCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const &renderPassMultiviewCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassMultiviewCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassMultiviewCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassMultiviewCreateInfo.subpassCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassMultiviewCreateInfo.pViewMasks);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassMultiviewCreateInfo.dependencyCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassMultiviewCreateInfo.pViewOffsets);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassMultiviewCreateInfo.correlationMaskCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassMultiviewCreateInfo.pCorrelationMasks);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const &subpassSampleLocationsEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassSampleLocationsEXT.subpassIndex);
		VULKAN_HPP_HASH_COMBINE(seed, subpassSampleLocationsEXT.sampleLocationsInfo);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const &renderPassSampleLocationsBeginInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassSampleLocationsBeginInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassSampleLocationsBeginInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const &renderPassTransformBeginInfoQCOM) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderPassTransformBeginInfoQCOM.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassTransformBeginInfoQCOM.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderPassTransformBeginInfoQCOM.transform);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const &renderingFragmentDensityMapAttachmentInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentDensityMapAttachmentInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView);
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const &renderingFragmentShadingRateAttachmentInfoKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentShadingRateAttachmentInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView);
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::RenderingInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::RenderingInfo const &renderingInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.renderArea);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.layerCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.viewMask);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.colorAttachmentCount);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.pColorAttachments);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.pDepthAttachment);
		VULKAN_HPP_HASH_COMBINE(seed, renderingInfo.pStencilAttachment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ResolveImageInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const &resolveImageInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, resolveImageInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, resolveImageInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, resolveImageInfo2.srcImage);
		VULKAN_HPP_HASH_COMBINE(seed, resolveImageInfo2.srcImageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, resolveImageInfo2.dstImage);
		VULKAN_HPP_HASH_COMBINE(seed, resolveImageInfo2.dstImageLayout);
		VULKAN_HPP_HASH_COMBINE(seed, resolveImageInfo2.regionCount);
		VULKAN_HPP_HASH_COMBINE(seed, resolveImageInfo2.pRegions);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT>
{
	std::size_t operator()(
	    VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const &samplerBorderColorComponentMappingCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, samplerBorderColorComponentMappingCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, samplerBorderColorComponentMappingCreateInfoEXT.components);
		VULKAN_HPP_HASH_COMBINE(seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SamplerCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SamplerCreateInfo const &samplerCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.magFilter);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.minFilter);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.mipmapMode);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.addressModeU);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.addressModeV);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.addressModeW);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.mipLodBias);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.anisotropyEnable);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.maxAnisotropy);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.compareEnable);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.compareOp);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.minLod);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.maxLod);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.borderColor);
		VULKAN_HPP_HASH_COMBINE(seed, samplerCreateInfo.unnormalizedCoordinates);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const &samplerReductionModeCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, samplerReductionModeCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, samplerReductionModeCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, samplerReductionModeCreateInfo.reductionMode);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const &samplerYcbcrConversionCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.format);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.ycbcrModel);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.ycbcrRange);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.components);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.xChromaOffset);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.yChromaOffset);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.chromaFilter);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const &samplerYcbcrConversionImageFormatProperties) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionImageFormatProperties.sType);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionImageFormatProperties.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const &samplerYcbcrConversionInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, samplerYcbcrConversionInfo.conversion);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_SCREEN_QNX)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const &screenSurfaceCreateInfoQNX) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, screenSurfaceCreateInfoQNX.sType);
		VULKAN_HPP_HASH_COMBINE(seed, screenSurfaceCreateInfoQNX.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, screenSurfaceCreateInfoQNX.flags);
		VULKAN_HPP_HASH_COMBINE(seed, screenSurfaceCreateInfoQNX.context);
		VULKAN_HPP_HASH_COMBINE(seed, screenSurfaceCreateInfoQNX.window);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_SCREEN_QNX*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const &semaphoreCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreCreateInfo.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const &semaphoreGetFdInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetFdInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetFdInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetFdInfoKHR.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetFdInfoKHR.handleType);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const &semaphoreGetWin32HandleInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetWin32HandleInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetWin32HandleInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetWin32HandleInfoKHR.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetWin32HandleInfoKHR.handleType);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_FUCHSIA)
template<>
struct hash<VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const &semaphoreGetZirconHandleInfoFUCHSIA) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetZirconHandleInfoFUCHSIA.sType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_FUCHSIA*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const &semaphoreSignalInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSignalInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSignalInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSignalInfo.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSignalInfo.value);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const &semaphoreSubmitInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSubmitInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSubmitInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSubmitInfo.semaphore);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSubmitInfo.value);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSubmitInfo.stageMask);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreSubmitInfo.deviceIndex);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const &semaphoreTypeCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreTypeCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreTypeCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreTypeCreateInfo.semaphoreType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreTypeCreateInfo.initialValue);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const &semaphoreWaitInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreWaitInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreWaitInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreWaitInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreWaitInfo.semaphoreCount);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreWaitInfo.pSemaphores);
		VULKAN_HPP_HASH_COMBINE(seed, semaphoreWaitInfo.pValues);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const &setStateFlagsIndirectCommandNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, setStateFlagsIndirectCommandNV.data);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const &shaderModuleCreateInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, shaderModuleCreateInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, shaderModuleCreateInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, shaderModuleCreateInfo.flags);
		VULKAN_HPP_HASH_COMBINE(seed, shaderModuleCreateInfo.codeSize);
		VULKAN_HPP_HASH_COMBINE(seed, shaderModuleCreateInfo.pCode);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const &shaderModuleValidationCacheCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, shaderModuleValidationCacheCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, shaderModuleValidationCacheCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, shaderModuleValidationCacheCreateInfoEXT.validationCache);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const &shaderResourceUsageAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, shaderResourceUsageAMD.numUsedVgprs);
		VULKAN_HPP_HASH_COMBINE(seed, shaderResourceUsageAMD.numUsedSgprs);
		VULKAN_HPP_HASH_COMBINE(seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup);
		VULKAN_HPP_HASH_COMBINE(seed, shaderResourceUsageAMD.ldsUsageSizeInBytes);
		VULKAN_HPP_HASH_COMBINE(seed, shaderResourceUsageAMD.scratchMemUsageInBytes);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const &shaderStatisticsInfoAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, shaderStatisticsInfoAMD.shaderStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, shaderStatisticsInfoAMD.resourceUsage);
		VULKAN_HPP_HASH_COMBINE(seed, shaderStatisticsInfoAMD.numPhysicalVgprs);
		VULKAN_HPP_HASH_COMBINE(seed, shaderStatisticsInfoAMD.numPhysicalSgprs);
		VULKAN_HPP_HASH_COMBINE(seed, shaderStatisticsInfoAMD.numAvailableVgprs);
		VULKAN_HPP_HASH_COMBINE(seed, shaderStatisticsInfoAMD.numAvailableSgprs);
		for(size_t i = 0; i < 3; ++i)
		{
			VULKAN_HPP_HASH_COMBINE(seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i]);
		}
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const &sharedPresentSurfaceCapabilitiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sharedPresentSurfaceCapabilitiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, sharedPresentSurfaceCapabilitiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const &sparseImageFormatProperties) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageFormatProperties.aspectMask);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageFormatProperties.imageGranularity);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageFormatProperties.flags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const &sparseImageFormatProperties2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageFormatProperties2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageFormatProperties2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageFormatProperties2.properties);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const &sparseImageMemoryRequirements) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryRequirements.formatProperties);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryRequirements.imageMipTailFirstLod);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryRequirements.imageMipTailSize);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryRequirements.imageMipTailOffset);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryRequirements.imageMipTailStride);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const &sparseImageMemoryRequirements2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryRequirements2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryRequirements2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, sparseImageMemoryRequirements2.memoryRequirements);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_GGP)
template<>
struct hash<VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const &streamDescriptorSurfaceCreateInfoGGP) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, streamDescriptorSurfaceCreateInfoGGP.sType);
		VULKAN_HPP_HASH_COMBINE(seed, streamDescriptorSurfaceCreateInfoGGP.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, streamDescriptorSurfaceCreateInfoGGP.flags);
		VULKAN_HPP_HASH_COMBINE(seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_GGP*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const &stridedDeviceAddressRegionKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, stridedDeviceAddressRegionKHR.deviceAddress);
		VULKAN_HPP_HASH_COMBINE(seed, stridedDeviceAddressRegionKHR.stride);
		VULKAN_HPP_HASH_COMBINE(seed, stridedDeviceAddressRegionKHR.size);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubmitInfo const &submitInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.waitSemaphoreCount);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.pWaitSemaphores);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.pWaitDstStageMask);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.commandBufferCount);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.pCommandBuffers);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.signalSemaphoreCount);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo.pSignalSemaphores);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubmitInfo2>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubmitInfo2 const &submitInfo2) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.sType);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.flags);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.waitSemaphoreInfoCount);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.pWaitSemaphoreInfos);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.commandBufferInfoCount);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.pCommandBufferInfos);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.signalSemaphoreInfoCount);
		VULKAN_HPP_HASH_COMBINE(seed, submitInfo2.pSignalSemaphoreInfos);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassBeginInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubpassBeginInfo const &subpassBeginInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassBeginInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, subpassBeginInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, subpassBeginInfo.contents);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const &subpassDescriptionDepthStencilResolve) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescriptionDepthStencilResolve.sType);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescriptionDepthStencilResolve.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescriptionDepthStencilResolve.depthResolveMode);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescriptionDepthStencilResolve.stencilResolveMode);
		VULKAN_HPP_HASH_COMBINE(seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassEndInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubpassEndInfo const &subpassEndInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassEndInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, subpassEndInfo.pNext);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM const &subpassFragmentDensityMapOffsetEndInfoQCOM) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassFragmentDensityMapOffsetEndInfoQCOM.sType);
		VULKAN_HPP_HASH_COMBINE(seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, subpassFragmentDensityMapOffsetEndInfoQCOM.fragmentDensityOffsetCount);
		VULKAN_HPP_HASH_COMBINE(seed, subpassFragmentDensityMapOffsetEndInfoQCOM.pFragmentDensityOffsets);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const &subpassShadingPipelineCreateInfoHUAWEI) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, subpassShadingPipelineCreateInfoHUAWEI.sType);
		VULKAN_HPP_HASH_COMBINE(seed, subpassShadingPipelineCreateInfoHUAWEI.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass);
		VULKAN_HPP_HASH_COMBINE(seed, subpassShadingPipelineCreateInfoHUAWEI.subpass);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const &surfaceCapabilities2EXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.minImageCount);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.maxImageCount);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.currentExtent);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.minImageExtent);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.maxImageExtent);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.maxImageArrayLayers);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.supportedTransforms);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.currentTransform);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.supportedCompositeAlpha);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.supportedUsageFlags);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2EXT.supportedSurfaceCounters);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const &surfaceCapabilitiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.minImageCount);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.maxImageCount);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.currentExtent);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.minImageExtent);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.maxImageExtent);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.maxImageArrayLayers);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.supportedTransforms);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.currentTransform);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.supportedCompositeAlpha);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesKHR.supportedUsageFlags);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const &surfaceCapabilities2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilities2KHR.surfaceCapabilities);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const &surfaceCapabilitiesFullScreenExclusiveEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormatKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const &surfaceFormatKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFormatKHR.format);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFormatKHR.colorSpace);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const &surfaceFormat2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFormat2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFormat2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFormat2KHR.surfaceFormat);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const &surfaceFullScreenExclusiveInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFullScreenExclusiveInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFullScreenExclusiveInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const &surfaceFullScreenExclusiveWin32InfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFullScreenExclusiveWin32InfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const &surfaceProtectedCapabilitiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, surfaceProtectedCapabilitiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceProtectedCapabilitiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, surfaceProtectedCapabilitiesKHR.supportsProtected);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const &swapchainCounterCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCounterCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCounterCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCounterCreateInfoEXT.surfaceCounters);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const &swapchainCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.surface);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.minImageCount);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.imageFormat);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.imageColorSpace);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.imageExtent);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.imageArrayLayers);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.imageUsage);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.imageSharingMode);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.queueFamilyIndexCount);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.pQueueFamilyIndices);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.preTransform);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.compositeAlpha);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.presentMode);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.clipped);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainCreateInfoKHR.oldSwapchain);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const &swapchainDisplayNativeHdrCreateInfoAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, swapchainDisplayNativeHdrCreateInfoAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const &textureLODGatherFormatPropertiesAMD) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, textureLODGatherFormatPropertiesAMD.sType);
		VULKAN_HPP_HASH_COMBINE(seed, textureLODGatherFormatPropertiesAMD.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const &timelineSemaphoreSubmitInfo) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, timelineSemaphoreSubmitInfo.sType);
		VULKAN_HPP_HASH_COMBINE(seed, timelineSemaphoreSubmitInfo.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount);
		VULKAN_HPP_HASH_COMBINE(seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues);
		VULKAN_HPP_HASH_COMBINE(seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount);
		VULKAN_HPP_HASH_COMBINE(seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const &traceRaysIndirectCommandKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, traceRaysIndirectCommandKHR.width);
		VULKAN_HPP_HASH_COMBINE(seed, traceRaysIndirectCommandKHR.height);
		VULKAN_HPP_HASH_COMBINE(seed, traceRaysIndirectCommandKHR.depth);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const &validationCacheCreateInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, validationCacheCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, validationCacheCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, validationCacheCreateInfoEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, validationCacheCreateInfoEXT.initialDataSize);
		VULKAN_HPP_HASH_COMBINE(seed, validationCacheCreateInfoEXT.pInitialData);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const &validationFeaturesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, validationFeaturesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, validationFeaturesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, validationFeaturesEXT.enabledValidationFeatureCount);
		VULKAN_HPP_HASH_COMBINE(seed, validationFeaturesEXT.pEnabledValidationFeatures);
		VULKAN_HPP_HASH_COMBINE(seed, validationFeaturesEXT.disabledValidationFeatureCount);
		VULKAN_HPP_HASH_COMBINE(seed, validationFeaturesEXT.pDisabledValidationFeatures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::ValidationFlagsEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const &validationFlagsEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, validationFlagsEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, validationFlagsEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, validationFlagsEXT.disabledValidationCheckCount);
		VULKAN_HPP_HASH_COMBINE(seed, validationFlagsEXT.pDisabledValidationChecks);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const &vertexInputAttributeDescription2EXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription2EXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription2EXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription2EXT.location);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription2EXT.binding);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription2EXT.format);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputAttributeDescription2EXT.offset);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const &vertexInputBindingDescription2EXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription2EXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription2EXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription2EXT.binding);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription2EXT.stride);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription2EXT.inputRate);
		VULKAN_HPP_HASH_COMBINE(seed, vertexInputBindingDescription2EXT.divisor);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_VI_NN)
template<>
struct hash<VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const &viSurfaceCreateInfoNN) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, viSurfaceCreateInfoNN.sType);
		VULKAN_HPP_HASH_COMBINE(seed, viSurfaceCreateInfoNN.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, viSurfaceCreateInfoNN.flags);
		VULKAN_HPP_HASH_COMBINE(seed, viSurfaceCreateInfoNN.window);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_VI_NN*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoPictureResourceKHR const &videoPictureResourceKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoPictureResourceKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoPictureResourceKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoPictureResourceKHR.codedOffset);
		VULKAN_HPP_HASH_COMBINE(seed, videoPictureResourceKHR.codedExtent);
		VULKAN_HPP_HASH_COMBINE(seed, videoPictureResourceKHR.baseArrayLayer);
		VULKAN_HPP_HASH_COMBINE(seed, videoPictureResourceKHR.imageViewBinding);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoReferenceSlotKHR const &videoReferenceSlotKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoReferenceSlotKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoReferenceSlotKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoReferenceSlotKHR.slotIndex);
		VULKAN_HPP_HASH_COMBINE(seed, videoReferenceSlotKHR.pPictureResource);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const &videoBeginCodingInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoBeginCodingInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoBeginCodingInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoBeginCodingInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, videoBeginCodingInfoKHR.codecQualityPreset);
		VULKAN_HPP_HASH_COMBINE(seed, videoBeginCodingInfoKHR.videoSession);
		VULKAN_HPP_HASH_COMBINE(seed, videoBeginCodingInfoKHR.videoSessionParameters);
		VULKAN_HPP_HASH_COMBINE(seed, videoBeginCodingInfoKHR.referenceSlotCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoBeginCodingInfoKHR.pReferenceSlots);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoBindMemoryKHR const &videoBindMemoryKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoBindMemoryKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoBindMemoryKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoBindMemoryKHR.memoryBindIndex);
		VULKAN_HPP_HASH_COMBINE(seed, videoBindMemoryKHR.memory);
		VULKAN_HPP_HASH_COMBINE(seed, videoBindMemoryKHR.memoryOffset);
		VULKAN_HPP_HASH_COMBINE(seed, videoBindMemoryKHR.memorySize);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const &videoCapabilitiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.capabilityFlags);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.videoPictureExtentGranularity);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.minExtent);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.maxExtent);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.maxReferencePicturesSlotsCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.maxReferencePicturesActiveCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoCapabilitiesKHR.stdHeaderVersion);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const &videoCodingControlInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoCodingControlInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoCodingControlInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoCodingControlInfoKHR.flags);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const &videoDecodeCapabilitiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeCapabilitiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeCapabilitiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeCapabilitiesKHR.flags);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesEXT const &videoDecodeH264CapabilitiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264CapabilitiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264CapabilitiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264CapabilitiesEXT.maxLevel);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264CapabilitiesEXT.fieldOffsetGranularity);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoEXT const &videoDecodeH264DpbSlotInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264DpbSlotInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264DpbSlotInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264DpbSlotInfoEXT.pStdReferenceInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH264MvcEXT const &videoDecodeH264MvcEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264MvcEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264MvcEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264MvcEXT.pStdMvc);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoEXT const &videoDecodeH264PictureInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264PictureInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264PictureInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264PictureInfoEXT.pStdPictureInfo);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264PictureInfoEXT.slicesCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264PictureInfoEXT.pSlicesDataOffsets);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileEXT const &videoDecodeH264ProfileEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264ProfileEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264ProfileEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264ProfileEXT.stdProfileIdc);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264ProfileEXT.pictureLayout);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoEXT const &videoDecodeH264SessionParametersAddInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersAddInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersAddInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersAddInfoEXT.spsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersAddInfoEXT.pSpsStd);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersAddInfoEXT.ppsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersAddInfoEXT.pPpsStd);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoEXT const &videoDecodeH264SessionParametersCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersCreateInfoEXT.maxSpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersCreateInfoEXT.maxPpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH264SessionParametersCreateInfoEXT.pParametersAddInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesEXT const &videoDecodeH265CapabilitiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265CapabilitiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265CapabilitiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265CapabilitiesEXT.maxLevel);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoEXT const &videoDecodeH265DpbSlotInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265DpbSlotInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265DpbSlotInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265DpbSlotInfoEXT.pStdReferenceInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoEXT const &videoDecodeH265PictureInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265PictureInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265PictureInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265PictureInfoEXT.pStdPictureInfo);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265PictureInfoEXT.slicesCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265PictureInfoEXT.pSlicesDataOffsets);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileEXT const &videoDecodeH265ProfileEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265ProfileEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265ProfileEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265ProfileEXT.stdProfileIdc);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoEXT const &videoDecodeH265SessionParametersAddInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersAddInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersAddInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersAddInfoEXT.vpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersAddInfoEXT.pVpsStd);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersAddInfoEXT.spsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersAddInfoEXT.pSpsStd);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersAddInfoEXT.ppsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersAddInfoEXT.pPpsStd);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoEXT const &videoDecodeH265SessionParametersCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersCreateInfoEXT.maxVpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersCreateInfoEXT.maxSpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersCreateInfoEXT.maxPpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeH265SessionParametersCreateInfoEXT.pParametersAddInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const &videoDecodeInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.srcBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.srcBufferOffset);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.srcBufferRange);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.dstPictureResource);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.pSetupReferenceSlot);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.referenceSlotCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoDecodeInfoKHR.pReferenceSlots);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const &videoEncodeCapabilitiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeCapabilitiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeCapabilitiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeCapabilitiesKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeCapabilitiesKHR.rateControlModes);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeCapabilitiesKHR.rateControlLayerCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeCapabilitiesKHR.qualityLevelCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeCapabilitiesKHR.inputImageDataFillAlignment);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesEXT const &videoEncodeH264CapabilitiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.inputModeFlags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.outputModeFlags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.maxPPictureL0ReferenceCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.maxBPictureL0ReferenceCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.maxL1ReferenceCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.motionVectorsOverPicBoundariesFlag);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.maxBytesPerPicDenom);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.maxBitsPerMbDenom);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.log2MaxMvLengthHorizontal);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264CapabilitiesEXT.log2MaxMvLengthVertical);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoEXT const &videoEncodeH264DpbSlotInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264DpbSlotInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264DpbSlotInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264DpbSlotInfoEXT.slotIndex);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264DpbSlotInfoEXT.pStdReferenceInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264EmitPictureParametersEXT const &videoEncodeH264EmitPictureParametersEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264EmitPictureParametersEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264EmitPictureParametersEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264EmitPictureParametersEXT.spsId);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264EmitPictureParametersEXT.emitSpsEnable);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264EmitPictureParametersEXT.ppsIdEntries);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeEXT const &videoEncodeH264FrameSizeEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264FrameSizeEXT.frameISize);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264FrameSizeEXT.framePSize);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264FrameSizeEXT.frameBSize);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264ReferenceListsEXT const &videoEncodeH264ReferenceListsEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ReferenceListsEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ReferenceListsEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ReferenceListsEXT.referenceList0EntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ReferenceListsEXT.pReferenceList0Entries);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ReferenceListsEXT.referenceList1EntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ReferenceListsEXT.pReferenceList1Entries);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ReferenceListsEXT.pMemMgmtCtrlOperations);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceEXT const &videoEncodeH264NaluSliceEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264NaluSliceEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264NaluSliceEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264NaluSliceEXT.mbCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264NaluSliceEXT.pReferenceFinalLists);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264NaluSliceEXT.pSliceHeaderStd);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileEXT const &videoEncodeH264ProfileEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ProfileEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ProfileEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264ProfileEXT.stdProfileIdc);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264QpEXT const &videoEncodeH264QpEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264QpEXT.qpI);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264QpEXT.qpP);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264QpEXT.qpB);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoEXT const &videoEncodeH264RateControlInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlInfoEXT.gopFrameCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlInfoEXT.idrPeriod);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlInfoEXT.consecutiveBFrameCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlInfoEXT.rateControlStructure);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlInfoEXT.temporalLayerCount);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoEXT const &videoEncodeH264RateControlLayerInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.temporalLayerId);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.useInitialRcQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.initialRcQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.useMinQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.minQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.useMaxQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.maxQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.useMaxFrameSize);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264RateControlLayerInfoEXT.maxFrameSize);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoEXT const &videoEncodeH264SessionParametersAddInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersAddInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersAddInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersAddInfoEXT.spsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersAddInfoEXT.pSpsStd);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersAddInfoEXT.ppsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersAddInfoEXT.pPpsStd);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoEXT const &videoEncodeH264SessionParametersCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersCreateInfoEXT.maxSpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersCreateInfoEXT.maxPpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264SessionParametersCreateInfoEXT.pParametersAddInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH264VclFrameInfoEXT const &videoEncodeH264VclFrameInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264VclFrameInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264VclFrameInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264VclFrameInfoEXT.pReferenceFinalLists);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264VclFrameInfoEXT.naluSliceEntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264VclFrameInfoEXT.pNaluSliceEntries);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH264VclFrameInfoEXT.pCurrentPictureInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesEXT const &videoEncodeH265CapabilitiesEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.flags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.inputModeFlags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.outputModeFlags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.ctbSizes);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.transformBlockSizes);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxPPictureL0ReferenceCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxBPictureL0ReferenceCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxL1ReferenceCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxSubLayersCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.minLog2MinLumaCodingBlockSizeMinus3);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxLog2MinLumaCodingBlockSizeMinus3);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.minLog2MinLumaTransformBlockSizeMinus2);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxLog2MinLumaTransformBlockSizeMinus2);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.minMaxTransformHierarchyDepthInter);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxMaxTransformHierarchyDepthInter);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.minMaxTransformHierarchyDepthIntra);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxMaxTransformHierarchyDepthIntra);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxDiffCuQpDeltaDepth);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.minMaxNumMergeCand);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265CapabilitiesEXT.maxMaxNumMergeCand);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoEXT const &videoEncodeH265DpbSlotInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265DpbSlotInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265DpbSlotInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265DpbSlotInfoEXT.slotIndex);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265DpbSlotInfoEXT.pStdReferenceInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265EmitPictureParametersEXT const &videoEncodeH265EmitPictureParametersEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265EmitPictureParametersEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265EmitPictureParametersEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265EmitPictureParametersEXT.vpsId);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265EmitPictureParametersEXT.spsId);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265EmitPictureParametersEXT.emitVpsEnable);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265EmitPictureParametersEXT.emitSpsEnable);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265EmitPictureParametersEXT.ppsIdEntries);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeEXT const &videoEncodeH265FrameSizeEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265FrameSizeEXT.frameISize);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265FrameSizeEXT.framePSize);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265FrameSizeEXT.frameBSize);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265ReferenceListsEXT const &videoEncodeH265ReferenceListsEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ReferenceListsEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ReferenceListsEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ReferenceListsEXT.referenceList0EntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ReferenceListsEXT.pReferenceList0Entries);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ReferenceListsEXT.referenceList1EntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ReferenceListsEXT.pReferenceList1Entries);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ReferenceListsEXT.pReferenceModifications);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentEXT const &videoEncodeH265NaluSliceSegmentEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265NaluSliceSegmentEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265NaluSliceSegmentEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265NaluSliceSegmentEXT.ctbCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265NaluSliceSegmentEXT.pReferenceFinalLists);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265NaluSliceSegmentEXT.pSliceSegmentHeaderStd);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileEXT const &videoEncodeH265ProfileEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ProfileEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ProfileEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265ProfileEXT.stdProfileIdc);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265QpEXT const &videoEncodeH265QpEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265QpEXT.qpI);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265QpEXT.qpP);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265QpEXT.qpB);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoEXT const &videoEncodeH265RateControlInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlInfoEXT.gopFrameCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlInfoEXT.idrPeriod);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlInfoEXT.consecutiveBFrameCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlInfoEXT.rateControlStructure);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlInfoEXT.subLayerCount);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoEXT const &videoEncodeH265RateControlLayerInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.temporalId);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.useInitialRcQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.initialRcQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.useMinQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.minQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.useMaxQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.maxQp);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.useMaxFrameSize);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265RateControlLayerInfoEXT.maxFrameSize);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoEXT const &videoEncodeH265SessionParametersAddInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersAddInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersAddInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersAddInfoEXT.vpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersAddInfoEXT.pVpsStd);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersAddInfoEXT.spsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersAddInfoEXT.pSpsStd);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersAddInfoEXT.ppsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersAddInfoEXT.pPpsStd);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoEXT const &videoEncodeH265SessionParametersCreateInfoEXT) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersCreateInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersCreateInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersCreateInfoEXT.maxVpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersCreateInfoEXT.maxSpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersCreateInfoEXT.maxPpsStdCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265SessionParametersCreateInfoEXT.pParametersAddInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeH265VclFrameInfoEXT const &videoEncodeH265VclFrameInfoEXT) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265VclFrameInfoEXT.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265VclFrameInfoEXT.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265VclFrameInfoEXT.pReferenceFinalLists);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265VclFrameInfoEXT.naluSliceSegmentEntryCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265VclFrameInfoEXT.pNaluSliceSegmentEntries);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeH265VclFrameInfoEXT.pCurrentPictureInfo);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const &videoEncodeInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.qualityLevel);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.dstBitstreamBuffer);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.dstBitstreamBufferOffset);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.dstBitstreamBufferMaxRange);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.srcPictureResource);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.pSetupReferenceSlot);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.referenceSlotCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.pReferenceSlots);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const &videoEncodeRateControlLayerInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlLayerInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlLayerInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlLayerInfoKHR.averageBitrate);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlLayerInfoKHR.maxBitrate);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlLayerInfoKHR.virtualBufferSizeInMs);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlLayerInfoKHR.initialVirtualBufferSizeInMs);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const &videoEncodeRateControlInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlInfoKHR.rateControlMode);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlInfoKHR.layerCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoEncodeRateControlInfoKHR.pLayerConfigs);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const &videoEndCodingInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoEndCodingInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoEndCodingInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoEndCodingInfoKHR.flags);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const &videoFormatPropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoFormatPropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoFormatPropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoFormatPropertiesKHR.format);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoGetMemoryPropertiesKHR const &videoGetMemoryPropertiesKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoGetMemoryPropertiesKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoGetMemoryPropertiesKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoGetMemoryPropertiesKHR.memoryBindIndex);
		VULKAN_HPP_HASH_COMBINE(seed, videoGetMemoryPropertiesKHR.pMemoryRequirements);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoQueueFamilyProperties2KHR const &videoQueueFamilyProperties2KHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoQueueFamilyProperties2KHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoQueueFamilyProperties2KHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoQueueFamilyProperties2KHR.videoCodecOperations);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const &videoSessionCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.queueFamilyIndex);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.pVideoProfile);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.pictureFormat);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.maxCodedExtent);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.referencePicturesFormat);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.maxReferencePicturesSlotsCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.maxReferencePicturesActiveCount);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionCreateInfoKHR.pStdHeaderVersion);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const &videoSessionParametersCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionParametersCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionParametersCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionParametersCreateInfoKHR.videoSession);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_ENABLE_BETA_EXTENSIONS)
template<>
struct hash<VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const &videoSessionParametersUpdateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionParametersUpdateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionParametersUpdateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount);
		return seed;
	}
};
#	endif /*VK_ENABLE_BETA_EXTENSIONS*/

#	if defined(VK_USE_PLATFORM_WAYLAND_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const &waylandSurfaceCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, waylandSurfaceCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, waylandSurfaceCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, waylandSurfaceCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, waylandSurfaceCreateInfoKHR.display);
		VULKAN_HPP_HASH_COMBINE(seed, waylandSurfaceCreateInfoKHR.surface);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WAYLAND_KHR*/

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const &win32KeyedMutexAcquireReleaseInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const &win32KeyedMutexAcquireReleaseInfoNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs);
		VULKAN_HPP_HASH_COMBINE(seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

#	if defined(VK_USE_PLATFORM_WIN32_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const &win32SurfaceCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, win32SurfaceCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, win32SurfaceCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, win32SurfaceCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, win32SurfaceCreateInfoKHR.hinstance);
		VULKAN_HPP_HASH_COMBINE(seed, win32SurfaceCreateInfoKHR.hwnd);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_WIN32_KHR*/

template<>
struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSet>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::WriteDescriptorSet const &writeDescriptorSet) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.sType);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.dstSet);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.dstBinding);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.dstArrayElement);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.descriptorCount);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.descriptorType);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.pImageInfo);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.pBufferInfo);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSet.pTexelBufferView);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const &writeDescriptorSetAccelerationStructureKHR) const
	    VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetAccelerationStructureKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetAccelerationStructureKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV>
{
	std::size_t
	operator()(VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const &writeDescriptorSetAccelerationStructureNV) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetAccelerationStructureNV.sType);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetAccelerationStructureNV.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures);
		return seed;
	}
};

template<>
struct hash<VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const &writeDescriptorSetInlineUniformBlock) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetInlineUniformBlock.sType);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetInlineUniformBlock.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetInlineUniformBlock.dataSize);
		VULKAN_HPP_HASH_COMBINE(seed, writeDescriptorSetInlineUniformBlock.pData);
		return seed;
	}
};

#	if defined(VK_USE_PLATFORM_XCB_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const &xcbSurfaceCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, xcbSurfaceCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, xcbSurfaceCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, xcbSurfaceCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, xcbSurfaceCreateInfoKHR.connection);
		VULKAN_HPP_HASH_COMBINE(seed, xcbSurfaceCreateInfoKHR.window);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_XCB_KHR*/

#	if defined(VK_USE_PLATFORM_XLIB_KHR)
template<>
struct hash<VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR>
{
	std::size_t operator()(VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const &xlibSurfaceCreateInfoKHR) const VULKAN_HPP_NOEXCEPT
	{
		std::size_t seed = 0;
		VULKAN_HPP_HASH_COMBINE(seed, xlibSurfaceCreateInfoKHR.sType);
		VULKAN_HPP_HASH_COMBINE(seed, xlibSurfaceCreateInfoKHR.pNext);
		VULKAN_HPP_HASH_COMBINE(seed, xlibSurfaceCreateInfoKHR.flags);
		VULKAN_HPP_HASH_COMBINE(seed, xlibSurfaceCreateInfoKHR.dpy);
		VULKAN_HPP_HASH_COMBINE(seed, xlibSurfaceCreateInfoKHR.window);
		return seed;
	}
};
#	endif /*VK_USE_PLATFORM_XLIB_KHR*/

#endif  // 14 <= VULKAN_HPP_CPP_VERSION

}  // namespace std
#endif  // VULKAN_HASH_HPP