text: /*
      Copyright (C) 2020 George Cave - gcave@stablecoder.ca
  
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
  
         http://www.apache.org/licenses/LICENSE-2.0
  
      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.
  */
  
  /*
      This file was auto-generated by the Vulkan mini-libs utility can be found at
      https://github.com/stablecoder/vulkan-mini-libs.git
      or
      https://git.stabletec.com/utilities/vulkan-mini-libs.git
  
      Check for an updated version anytime, or state concerns/bugs.
  */
  
  #ifndef VK_EQUALITY_CHECK_V91_HPP
  #define VK_EQUALITY_CHECK_V91_HPP
  
  /*  USAGE:
      To use, include this header where the declarations for the boolean checks are required.
  
      On *ONE* compilation unit, include the definition of `#define VK_EQUALITY_CHECK_CONFIG_MAIN`
      so that the definitions are compiled somewhere following the one definition rule.
  */
  
  #include <vulkan/vulkan.h>
  
  static_assert(VK_HEADER_VERSION == 91, "Incompatible VK_HEADER_VERSION!" );
  
  bool operator==(VkBaseOutStructure const &lhs,
                  VkBaseOutStructure const &rhs) noexcept;
  bool operator!=(VkBaseOutStructure const &lhs,
                  VkBaseOutStructure const &rhs) noexcept;
  
  bool operator==(VkBaseInStructure const &lhs,
                  VkBaseInStructure const &rhs) noexcept;
  bool operator!=(VkBaseInStructure const &lhs,
                  VkBaseInStructure const &rhs) noexcept;
  
  bool operator==(VkOffset2D const &lhs,
                  VkOffset2D const &rhs) noexcept;
  bool operator!=(VkOffset2D const &lhs,
                  VkOffset2D const &rhs) noexcept;
  
  bool operator==(VkOffset3D const &lhs,
                  VkOffset3D const &rhs) noexcept;
  bool operator!=(VkOffset3D const &lhs,
                  VkOffset3D const &rhs) noexcept;
  
  bool operator==(VkExtent2D const &lhs,
                  VkExtent2D const &rhs) noexcept;
  bool operator!=(VkExtent2D const &lhs,
                  VkExtent2D const &rhs) noexcept;
  
  bool operator==(VkExtent3D const &lhs,
                  VkExtent3D const &rhs) noexcept;
  bool operator!=(VkExtent3D const &lhs,
                  VkExtent3D const &rhs) noexcept;
  
  bool operator==(VkViewport const &lhs,
                  VkViewport const &rhs) noexcept;
  bool operator!=(VkViewport const &lhs,
                  VkViewport const &rhs) noexcept;
  
  bool operator==(VkRect2D const &lhs,
                  VkRect2D const &rhs) noexcept;
  bool operator!=(VkRect2D const &lhs,
                  VkRect2D const &rhs) noexcept;
  
  bool operator==(VkClearRect const &lhs,
                  VkClearRect const &rhs) noexcept;
  bool operator!=(VkClearRect const &lhs,
                  VkClearRect const &rhs) noexcept;
  
  bool operator==(VkComponentMapping const &lhs,
                  VkComponentMapping const &rhs) noexcept;
  bool operator!=(VkComponentMapping const &lhs,
                  VkComponentMapping const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceProperties const &lhs,
                  VkPhysicalDeviceProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceProperties const &lhs,
                  VkPhysicalDeviceProperties const &rhs) noexcept;
  
  bool operator==(VkExtensionProperties const &lhs,
                  VkExtensionProperties const &rhs) noexcept;
  bool operator!=(VkExtensionProperties const &lhs,
                  VkExtensionProperties const &rhs) noexcept;
  
  bool operator==(VkLayerProperties const &lhs,
                  VkLayerProperties const &rhs) noexcept;
  bool operator!=(VkLayerProperties const &lhs,
                  VkLayerProperties const &rhs) noexcept;
  
  bool operator==(VkApplicationInfo const &lhs,
                  VkApplicationInfo const &rhs) noexcept;
  bool operator!=(VkApplicationInfo const &lhs,
                  VkApplicationInfo const &rhs) noexcept;
  
  bool operator==(VkAllocationCallbacks const &lhs,
                  VkAllocationCallbacks const &rhs) noexcept;
  bool operator!=(VkAllocationCallbacks const &lhs,
                  VkAllocationCallbacks const &rhs) noexcept;
  
  bool operator==(VkDeviceQueueCreateInfo const &lhs,
                  VkDeviceQueueCreateInfo const &rhs) noexcept;
  bool operator!=(VkDeviceQueueCreateInfo const &lhs,
                  VkDeviceQueueCreateInfo const &rhs) noexcept;
  
  bool operator==(VkQueueFamilyProperties const &lhs,
                  VkQueueFamilyProperties const &rhs) noexcept;
  bool operator!=(VkQueueFamilyProperties const &lhs,
                  VkQueueFamilyProperties const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceMemoryProperties const &lhs,
                  VkPhysicalDeviceMemoryProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceMemoryProperties const &lhs,
                  VkPhysicalDeviceMemoryProperties const &rhs) noexcept;
  
  bool operator==(VkMemoryAllocateInfo const &lhs,
                  VkMemoryAllocateInfo const &rhs) noexcept;
  bool operator!=(VkMemoryAllocateInfo const &lhs,
                  VkMemoryAllocateInfo const &rhs) noexcept;
  
  bool operator==(VkMemoryRequirements const &lhs,
                  VkMemoryRequirements const &rhs) noexcept;
  bool operator!=(VkMemoryRequirements const &lhs,
                  VkMemoryRequirements const &rhs) noexcept;
  
  bool operator==(VkSparseImageFormatProperties const &lhs,
                  VkSparseImageFormatProperties const &rhs) noexcept;
  bool operator!=(VkSparseImageFormatProperties const &lhs,
                  VkSparseImageFormatProperties const &rhs) noexcept;
  
  bool operator==(VkSparseImageMemoryRequirements const &lhs,
                  VkSparseImageMemoryRequirements const &rhs) noexcept;
  bool operator!=(VkSparseImageMemoryRequirements const &lhs,
                  VkSparseImageMemoryRequirements const &rhs) noexcept;
  
  bool operator==(VkMemoryType const &lhs,
                  VkMemoryType const &rhs) noexcept;
  bool operator!=(VkMemoryType const &lhs,
                  VkMemoryType const &rhs) noexcept;
  
  bool operator==(VkMemoryHeap const &lhs,
                  VkMemoryHeap const &rhs) noexcept;
  bool operator!=(VkMemoryHeap const &lhs,
                  VkMemoryHeap const &rhs) noexcept;
  
  bool operator==(VkMappedMemoryRange const &lhs,
                  VkMappedMemoryRange const &rhs) noexcept;
  bool operator!=(VkMappedMemoryRange const &lhs,
                  VkMappedMemoryRange const &rhs) noexcept;
  
  bool operator==(VkFormatProperties const &lhs,
                  VkFormatProperties const &rhs) noexcept;
  bool operator!=(VkFormatProperties const &lhs,
                  VkFormatProperties const &rhs) noexcept;
  
  bool operator==(VkImageFormatProperties const &lhs,
                  VkImageFormatProperties const &rhs) noexcept;
  bool operator!=(VkImageFormatProperties const &lhs,
                  VkImageFormatProperties const &rhs) noexcept;
  
  bool operator==(VkDescriptorBufferInfo const &lhs,
                  VkDescriptorBufferInfo const &rhs) noexcept;
  bool operator!=(VkDescriptorBufferInfo const &lhs,
                  VkDescriptorBufferInfo const &rhs) noexcept;
  
  bool operator==(VkDescriptorImageInfo const &lhs,
                  VkDescriptorImageInfo const &rhs) noexcept;
  bool operator!=(VkDescriptorImageInfo const &lhs,
                  VkDescriptorImageInfo const &rhs) noexcept;
  
  bool operator==(VkWriteDescriptorSet const &lhs,
                  VkWriteDescriptorSet const &rhs) noexcept;
  bool operator!=(VkWriteDescriptorSet const &lhs,
                  VkWriteDescriptorSet const &rhs) noexcept;
  
  bool operator==(VkCopyDescriptorSet const &lhs,
                  VkCopyDescriptorSet const &rhs) noexcept;
  bool operator!=(VkCopyDescriptorSet const &lhs,
                  VkCopyDescriptorSet const &rhs) noexcept;
  
  bool operator==(VkBufferCreateInfo const &lhs,
                  VkBufferCreateInfo const &rhs) noexcept;
  bool operator!=(VkBufferCreateInfo const &lhs,
                  VkBufferCreateInfo const &rhs) noexcept;
  
  bool operator==(VkBufferViewCreateInfo const &lhs,
                  VkBufferViewCreateInfo const &rhs) noexcept;
  bool operator!=(VkBufferViewCreateInfo const &lhs,
                  VkBufferViewCreateInfo const &rhs) noexcept;
  
  bool operator==(VkImageSubresource const &lhs,
                  VkImageSubresource const &rhs) noexcept;
  bool operator!=(VkImageSubresource const &lhs,
                  VkImageSubresource const &rhs) noexcept;
  
  bool operator==(VkImageSubresourceLayers const &lhs,
                  VkImageSubresourceLayers const &rhs) noexcept;
  bool operator!=(VkImageSubresourceLayers const &lhs,
                  VkImageSubresourceLayers const &rhs) noexcept;
  
  bool operator==(VkImageSubresourceRange const &lhs,
                  VkImageSubresourceRange const &rhs) noexcept;
  bool operator!=(VkImageSubresourceRange const &lhs,
                  VkImageSubresourceRange const &rhs) noexcept;
  
  bool operator==(VkMemoryBarrier const &lhs,
                  VkMemoryBarrier const &rhs) noexcept;
  bool operator!=(VkMemoryBarrier const &lhs,
                  VkMemoryBarrier const &rhs) noexcept;
  
  bool operator==(VkBufferMemoryBarrier const &lhs,
                  VkBufferMemoryBarrier const &rhs) noexcept;
  bool operator!=(VkBufferMemoryBarrier const &lhs,
                  VkBufferMemoryBarrier const &rhs) noexcept;
  
  bool operator==(VkImageMemoryBarrier const &lhs,
                  VkImageMemoryBarrier const &rhs) noexcept;
  bool operator!=(VkImageMemoryBarrier const &lhs,
                  VkImageMemoryBarrier const &rhs) noexcept;
  
  bool operator==(VkImageCreateInfo const &lhs,
                  VkImageCreateInfo const &rhs) noexcept;
  bool operator!=(VkImageCreateInfo const &lhs,
                  VkImageCreateInfo const &rhs) noexcept;
  
  bool operator==(VkSubresourceLayout const &lhs,
                  VkSubresourceLayout const &rhs) noexcept;
  bool operator!=(VkSubresourceLayout const &lhs,
                  VkSubresourceLayout const &rhs) noexcept;
  
  bool operator==(VkImageViewCreateInfo const &lhs,
                  VkImageViewCreateInfo const &rhs) noexcept;
  bool operator!=(VkImageViewCreateInfo const &lhs,
                  VkImageViewCreateInfo const &rhs) noexcept;
  
  bool operator==(VkBufferCopy const &lhs,
                  VkBufferCopy const &rhs) noexcept;
  bool operator!=(VkBufferCopy const &lhs,
                  VkBufferCopy const &rhs) noexcept;
  
  bool operator==(VkSparseMemoryBind const &lhs,
                  VkSparseMemoryBind const &rhs) noexcept;
  bool operator!=(VkSparseMemoryBind const &lhs,
                  VkSparseMemoryBind const &rhs) noexcept;
  
  bool operator==(VkSparseImageMemoryBind const &lhs,
                  VkSparseImageMemoryBind const &rhs) noexcept;
  bool operator!=(VkSparseImageMemoryBind const &lhs,
                  VkSparseImageMemoryBind const &rhs) noexcept;
  
  bool operator==(VkSparseBufferMemoryBindInfo const &lhs,
                  VkSparseBufferMemoryBindInfo const &rhs) noexcept;
  bool operator!=(VkSparseBufferMemoryBindInfo const &lhs,
                  VkSparseBufferMemoryBindInfo const &rhs) noexcept;
  
  bool operator==(VkSparseImageOpaqueMemoryBindInfo const &lhs,
                  VkSparseImageOpaqueMemoryBindInfo const &rhs) noexcept;
  bool operator!=(VkSparseImageOpaqueMemoryBindInfo const &lhs,
                  VkSparseImageOpaqueMemoryBindInfo const &rhs) noexcept;
  
  bool operator==(VkSparseImageMemoryBindInfo const &lhs,
                  VkSparseImageMemoryBindInfo const &rhs) noexcept;
  bool operator!=(VkSparseImageMemoryBindInfo const &lhs,
                  VkSparseImageMemoryBindInfo const &rhs) noexcept;
  
  bool operator==(VkBindSparseInfo const &lhs,
                  VkBindSparseInfo const &rhs) noexcept;
  bool operator!=(VkBindSparseInfo const &lhs,
                  VkBindSparseInfo const &rhs) noexcept;
  
  bool operator==(VkImageCopy const &lhs,
                  VkImageCopy const &rhs) noexcept;
  bool operator!=(VkImageCopy const &lhs,
                  VkImageCopy const &rhs) noexcept;
  
  bool operator==(VkImageBlit const &lhs,
                  VkImageBlit const &rhs) noexcept;
  bool operator!=(VkImageBlit const &lhs,
                  VkImageBlit const &rhs) noexcept;
  
  bool operator==(VkBufferImageCopy const &lhs,
                  VkBufferImageCopy const &rhs) noexcept;
  bool operator!=(VkBufferImageCopy const &lhs,
                  VkBufferImageCopy const &rhs) noexcept;
  
  bool operator==(VkImageResolve const &lhs,
                  VkImageResolve const &rhs) noexcept;
  bool operator!=(VkImageResolve const &lhs,
                  VkImageResolve const &rhs) noexcept;
  
  bool operator==(VkShaderModuleCreateInfo const &lhs,
                  VkShaderModuleCreateInfo const &rhs) noexcept;
  bool operator!=(VkShaderModuleCreateInfo const &lhs,
                  VkShaderModuleCreateInfo const &rhs) noexcept;
  
  bool operator==(VkDescriptorSetLayoutBinding const &lhs,
                  VkDescriptorSetLayoutBinding const &rhs) noexcept;
  bool operator!=(VkDescriptorSetLayoutBinding const &lhs,
                  VkDescriptorSetLayoutBinding const &rhs) noexcept;
  
  bool operator==(VkDescriptorSetLayoutCreateInfo const &lhs,
                  VkDescriptorSetLayoutCreateInfo const &rhs) noexcept;
  bool operator!=(VkDescriptorSetLayoutCreateInfo const &lhs,
                  VkDescriptorSetLayoutCreateInfo const &rhs) noexcept;
  
  bool operator==(VkDescriptorPoolSize const &lhs,
                  VkDescriptorPoolSize const &rhs) noexcept;
  bool operator!=(VkDescriptorPoolSize const &lhs,
                  VkDescriptorPoolSize const &rhs) noexcept;
  
  bool operator==(VkDescriptorPoolCreateInfo const &lhs,
                  VkDescriptorPoolCreateInfo const &rhs) noexcept;
  bool operator!=(VkDescriptorPoolCreateInfo const &lhs,
                  VkDescriptorPoolCreateInfo const &rhs) noexcept;
  
  bool operator==(VkDescriptorSetAllocateInfo const &lhs,
                  VkDescriptorSetAllocateInfo const &rhs) noexcept;
  bool operator!=(VkDescriptorSetAllocateInfo const &lhs,
                  VkDescriptorSetAllocateInfo const &rhs) noexcept;
  
  bool operator==(VkSpecializationMapEntry const &lhs,
                  VkSpecializationMapEntry const &rhs) noexcept;
  bool operator!=(VkSpecializationMapEntry const &lhs,
                  VkSpecializationMapEntry const &rhs) noexcept;
  
  bool operator==(VkSpecializationInfo const &lhs,
                  VkSpecializationInfo const &rhs) noexcept;
  bool operator!=(VkSpecializationInfo const &lhs,
                  VkSpecializationInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineShaderStageCreateInfo const &lhs,
                  VkPipelineShaderStageCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineShaderStageCreateInfo const &lhs,
                  VkPipelineShaderStageCreateInfo const &rhs) noexcept;
  
  bool operator==(VkComputePipelineCreateInfo const &lhs,
                  VkComputePipelineCreateInfo const &rhs) noexcept;
  bool operator!=(VkComputePipelineCreateInfo const &lhs,
                  VkComputePipelineCreateInfo const &rhs) noexcept;
  
  bool operator==(VkVertexInputBindingDescription const &lhs,
                  VkVertexInputBindingDescription const &rhs) noexcept;
  bool operator!=(VkVertexInputBindingDescription const &lhs,
                  VkVertexInputBindingDescription const &rhs) noexcept;
  
  bool operator==(VkVertexInputAttributeDescription const &lhs,
                  VkVertexInputAttributeDescription const &rhs) noexcept;
  bool operator!=(VkVertexInputAttributeDescription const &lhs,
                  VkVertexInputAttributeDescription const &rhs) noexcept;
  
  bool operator==(VkPipelineVertexInputStateCreateInfo const &lhs,
                  VkPipelineVertexInputStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineVertexInputStateCreateInfo const &lhs,
                  VkPipelineVertexInputStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineInputAssemblyStateCreateInfo const &lhs,
                  VkPipelineInputAssemblyStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineInputAssemblyStateCreateInfo const &lhs,
                  VkPipelineInputAssemblyStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineTessellationStateCreateInfo const &lhs,
                  VkPipelineTessellationStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineTessellationStateCreateInfo const &lhs,
                  VkPipelineTessellationStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineViewportStateCreateInfo const &lhs,
                  VkPipelineViewportStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineViewportStateCreateInfo const &lhs,
                  VkPipelineViewportStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineRasterizationStateCreateInfo const &lhs,
                  VkPipelineRasterizationStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineRasterizationStateCreateInfo const &lhs,
                  VkPipelineRasterizationStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineMultisampleStateCreateInfo const &lhs,
                  VkPipelineMultisampleStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineMultisampleStateCreateInfo const &lhs,
                  VkPipelineMultisampleStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineColorBlendAttachmentState const &lhs,
                  VkPipelineColorBlendAttachmentState const &rhs) noexcept;
  bool operator!=(VkPipelineColorBlendAttachmentState const &lhs,
                  VkPipelineColorBlendAttachmentState const &rhs) noexcept;
  
  bool operator==(VkPipelineColorBlendStateCreateInfo const &lhs,
                  VkPipelineColorBlendStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineColorBlendStateCreateInfo const &lhs,
                  VkPipelineColorBlendStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineDynamicStateCreateInfo const &lhs,
                  VkPipelineDynamicStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineDynamicStateCreateInfo const &lhs,
                  VkPipelineDynamicStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkStencilOpState const &lhs,
                  VkStencilOpState const &rhs) noexcept;
  bool operator!=(VkStencilOpState const &lhs,
                  VkStencilOpState const &rhs) noexcept;
  
  bool operator==(VkPipelineDepthStencilStateCreateInfo const &lhs,
                  VkPipelineDepthStencilStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineDepthStencilStateCreateInfo const &lhs,
                  VkPipelineDepthStencilStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkGraphicsPipelineCreateInfo const &lhs,
                  VkGraphicsPipelineCreateInfo const &rhs) noexcept;
  bool operator!=(VkGraphicsPipelineCreateInfo const &lhs,
                  VkGraphicsPipelineCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineCacheCreateInfo const &lhs,
                  VkPipelineCacheCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineCacheCreateInfo const &lhs,
                  VkPipelineCacheCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPushConstantRange const &lhs,
                  VkPushConstantRange const &rhs) noexcept;
  bool operator!=(VkPushConstantRange const &lhs,
                  VkPushConstantRange const &rhs) noexcept;
  
  bool operator==(VkPipelineLayoutCreateInfo const &lhs,
                  VkPipelineLayoutCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineLayoutCreateInfo const &lhs,
                  VkPipelineLayoutCreateInfo const &rhs) noexcept;
  
  bool operator==(VkSamplerCreateInfo const &lhs,
                  VkSamplerCreateInfo const &rhs) noexcept;
  bool operator!=(VkSamplerCreateInfo const &lhs,
                  VkSamplerCreateInfo const &rhs) noexcept;
  
  bool operator==(VkCommandPoolCreateInfo const &lhs,
                  VkCommandPoolCreateInfo const &rhs) noexcept;
  bool operator!=(VkCommandPoolCreateInfo const &lhs,
                  VkCommandPoolCreateInfo const &rhs) noexcept;
  
  bool operator==(VkCommandBufferAllocateInfo const &lhs,
                  VkCommandBufferAllocateInfo const &rhs) noexcept;
  bool operator!=(VkCommandBufferAllocateInfo const &lhs,
                  VkCommandBufferAllocateInfo const &rhs) noexcept;
  
  bool operator==(VkCommandBufferInheritanceInfo const &lhs,
                  VkCommandBufferInheritanceInfo const &rhs) noexcept;
  bool operator!=(VkCommandBufferInheritanceInfo const &lhs,
                  VkCommandBufferInheritanceInfo const &rhs) noexcept;
  
  bool operator==(VkCommandBufferBeginInfo const &lhs,
                  VkCommandBufferBeginInfo const &rhs) noexcept;
  bool operator!=(VkCommandBufferBeginInfo const &lhs,
                  VkCommandBufferBeginInfo const &rhs) noexcept;
  
  bool operator==(VkClearDepthStencilValue const &lhs,
                  VkClearDepthStencilValue const &rhs) noexcept;
  bool operator!=(VkClearDepthStencilValue const &lhs,
                  VkClearDepthStencilValue const &rhs) noexcept;
  
  bool operator==(VkAttachmentDescription const &lhs,
                  VkAttachmentDescription const &rhs) noexcept;
  bool operator!=(VkAttachmentDescription const &lhs,
                  VkAttachmentDescription const &rhs) noexcept;
  
  bool operator==(VkAttachmentReference const &lhs,
                  VkAttachmentReference const &rhs) noexcept;
  bool operator!=(VkAttachmentReference const &lhs,
                  VkAttachmentReference const &rhs) noexcept;
  
  bool operator==(VkSubpassDescription const &lhs,
                  VkSubpassDescription const &rhs) noexcept;
  bool operator!=(VkSubpassDescription const &lhs,
                  VkSubpassDescription const &rhs) noexcept;
  
  bool operator==(VkSubpassDependency const &lhs,
                  VkSubpassDependency const &rhs) noexcept;
  bool operator!=(VkSubpassDependency const &lhs,
                  VkSubpassDependency const &rhs) noexcept;
  
  bool operator==(VkRenderPassCreateInfo const &lhs,
                  VkRenderPassCreateInfo const &rhs) noexcept;
  bool operator!=(VkRenderPassCreateInfo const &lhs,
                  VkRenderPassCreateInfo const &rhs) noexcept;
  
  bool operator==(VkEventCreateInfo const &lhs,
                  VkEventCreateInfo const &rhs) noexcept;
  bool operator!=(VkEventCreateInfo const &lhs,
                  VkEventCreateInfo const &rhs) noexcept;
  
  bool operator==(VkFenceCreateInfo const &lhs,
                  VkFenceCreateInfo const &rhs) noexcept;
  bool operator!=(VkFenceCreateInfo const &lhs,
                  VkFenceCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceFeatures const &lhs,
                  VkPhysicalDeviceFeatures const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceFeatures const &lhs,
                  VkPhysicalDeviceFeatures const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceSparseProperties const &lhs,
                  VkPhysicalDeviceSparseProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceSparseProperties const &lhs,
                  VkPhysicalDeviceSparseProperties const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceLimits const &lhs,
                  VkPhysicalDeviceLimits const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceLimits const &lhs,
                  VkPhysicalDeviceLimits const &rhs) noexcept;
  
  bool operator==(VkSemaphoreCreateInfo const &lhs,
                  VkSemaphoreCreateInfo const &rhs) noexcept;
  bool operator!=(VkSemaphoreCreateInfo const &lhs,
                  VkSemaphoreCreateInfo const &rhs) noexcept;
  
  bool operator==(VkQueryPoolCreateInfo const &lhs,
                  VkQueryPoolCreateInfo const &rhs) noexcept;
  bool operator!=(VkQueryPoolCreateInfo const &lhs,
                  VkQueryPoolCreateInfo const &rhs) noexcept;
  
  bool operator==(VkFramebufferCreateInfo const &lhs,
                  VkFramebufferCreateInfo const &rhs) noexcept;
  bool operator!=(VkFramebufferCreateInfo const &lhs,
                  VkFramebufferCreateInfo const &rhs) noexcept;
  
  bool operator==(VkDrawIndirectCommand const &lhs,
                  VkDrawIndirectCommand const &rhs) noexcept;
  bool operator!=(VkDrawIndirectCommand const &lhs,
                  VkDrawIndirectCommand const &rhs) noexcept;
  
  bool operator==(VkDrawIndexedIndirectCommand const &lhs,
                  VkDrawIndexedIndirectCommand const &rhs) noexcept;
  bool operator!=(VkDrawIndexedIndirectCommand const &lhs,
                  VkDrawIndexedIndirectCommand const &rhs) noexcept;
  
  bool operator==(VkDispatchIndirectCommand const &lhs,
                  VkDispatchIndirectCommand const &rhs) noexcept;
  bool operator!=(VkDispatchIndirectCommand const &lhs,
                  VkDispatchIndirectCommand const &rhs) noexcept;
  
  bool operator==(VkSubmitInfo const &lhs,
                  VkSubmitInfo const &rhs) noexcept;
  bool operator!=(VkSubmitInfo const &lhs,
                  VkSubmitInfo const &rhs) noexcept;
  
  bool operator==(VkDisplayPropertiesKHR const &lhs,
                  VkDisplayPropertiesKHR const &rhs) noexcept;
  bool operator!=(VkDisplayPropertiesKHR const &lhs,
                  VkDisplayPropertiesKHR const &rhs) noexcept;
  
  bool operator==(VkDisplayPlanePropertiesKHR const &lhs,
                  VkDisplayPlanePropertiesKHR const &rhs) noexcept;
  bool operator!=(VkDisplayPlanePropertiesKHR const &lhs,
                  VkDisplayPlanePropertiesKHR const &rhs) noexcept;
  
  bool operator==(VkDisplayModeParametersKHR const &lhs,
                  VkDisplayModeParametersKHR const &rhs) noexcept;
  bool operator!=(VkDisplayModeParametersKHR const &lhs,
                  VkDisplayModeParametersKHR const &rhs) noexcept;
  
  bool operator==(VkDisplayModePropertiesKHR const &lhs,
                  VkDisplayModePropertiesKHR const &rhs) noexcept;
  bool operator!=(VkDisplayModePropertiesKHR const &lhs,
                  VkDisplayModePropertiesKHR const &rhs) noexcept;
  
  bool operator==(VkDisplayModeCreateInfoKHR const &lhs,
                  VkDisplayModeCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkDisplayModeCreateInfoKHR const &lhs,
                  VkDisplayModeCreateInfoKHR const &rhs) noexcept;
  
  bool operator==(VkDisplayPlaneCapabilitiesKHR const &lhs,
                  VkDisplayPlaneCapabilitiesKHR const &rhs) noexcept;
  bool operator!=(VkDisplayPlaneCapabilitiesKHR const &lhs,
                  VkDisplayPlaneCapabilitiesKHR const &rhs) noexcept;
  
  bool operator==(VkDisplaySurfaceCreateInfoKHR const &lhs,
                  VkDisplaySurfaceCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkDisplaySurfaceCreateInfoKHR const &lhs,
                  VkDisplaySurfaceCreateInfoKHR const &rhs) noexcept;
  
  bool operator==(VkDisplayPresentInfoKHR const &lhs,
                  VkDisplayPresentInfoKHR const &rhs) noexcept;
  bool operator!=(VkDisplayPresentInfoKHR const &lhs,
                  VkDisplayPresentInfoKHR const &rhs) noexcept;
  
  bool operator==(VkSurfaceCapabilitiesKHR const &lhs,
                  VkSurfaceCapabilitiesKHR const &rhs) noexcept;
  bool operator!=(VkSurfaceCapabilitiesKHR const &lhs,
                  VkSurfaceCapabilitiesKHR const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkAndroidSurfaceCreateInfoKHR const &lhs,
                  VkAndroidSurfaceCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkAndroidSurfaceCreateInfoKHR const &lhs,
                  VkAndroidSurfaceCreateInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_VI_NN
  bool operator==(VkViSurfaceCreateInfoNN const &lhs,
                  VkViSurfaceCreateInfoNN const &rhs) noexcept;
  bool operator!=(VkViSurfaceCreateInfoNN const &lhs,
                  VkViSurfaceCreateInfoNN const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_VI_NN
  
  #ifdef VK_USE_PLATFORM_WAYLAND_KHR
  bool operator==(VkWaylandSurfaceCreateInfoKHR const &lhs,
                  VkWaylandSurfaceCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkWaylandSurfaceCreateInfoKHR const &lhs,
                  VkWaylandSurfaceCreateInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WAYLAND_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkWin32SurfaceCreateInfoKHR const &lhs,
                  VkWin32SurfaceCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkWin32SurfaceCreateInfoKHR const &lhs,
                  VkWin32SurfaceCreateInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_XLIB_KHR
  bool operator==(VkXlibSurfaceCreateInfoKHR const &lhs,
                  VkXlibSurfaceCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkXlibSurfaceCreateInfoKHR const &lhs,
                  VkXlibSurfaceCreateInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_XLIB_KHR
  
  #ifdef VK_USE_PLATFORM_XCB_KHR
  bool operator==(VkXcbSurfaceCreateInfoKHR const &lhs,
                  VkXcbSurfaceCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkXcbSurfaceCreateInfoKHR const &lhs,
                  VkXcbSurfaceCreateInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_XCB_KHR
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  bool operator==(VkImagePipeSurfaceCreateInfoFUCHSIA const &lhs,
                  VkImagePipeSurfaceCreateInfoFUCHSIA const &rhs) noexcept;
  bool operator!=(VkImagePipeSurfaceCreateInfoFUCHSIA const &lhs,
                  VkImagePipeSurfaceCreateInfoFUCHSIA const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  bool operator==(VkSurfaceFormatKHR const &lhs,
                  VkSurfaceFormatKHR const &rhs) noexcept;
  bool operator!=(VkSurfaceFormatKHR const &lhs,
                  VkSurfaceFormatKHR const &rhs) noexcept;
  
  bool operator==(VkSwapchainCreateInfoKHR const &lhs,
                  VkSwapchainCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkSwapchainCreateInfoKHR const &lhs,
                  VkSwapchainCreateInfoKHR const &rhs) noexcept;
  
  bool operator==(VkPresentInfoKHR const &lhs,
                  VkPresentInfoKHR const &rhs) noexcept;
  bool operator!=(VkPresentInfoKHR const &lhs,
                  VkPresentInfoKHR const &rhs) noexcept;
  
  bool operator==(VkDebugReportCallbackCreateInfoEXT const &lhs,
                  VkDebugReportCallbackCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkDebugReportCallbackCreateInfoEXT const &lhs,
                  VkDebugReportCallbackCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkValidationFlagsEXT const &lhs,
                  VkValidationFlagsEXT const &rhs) noexcept;
  bool operator!=(VkValidationFlagsEXT const &lhs,
                  VkValidationFlagsEXT const &rhs) noexcept;
  
  bool operator==(VkPipelineRasterizationStateRasterizationOrderAMD const &lhs,
                  VkPipelineRasterizationStateRasterizationOrderAMD const &rhs) noexcept;
  bool operator!=(VkPipelineRasterizationStateRasterizationOrderAMD const &lhs,
                  VkPipelineRasterizationStateRasterizationOrderAMD const &rhs) noexcept;
  
  bool operator==(VkDebugMarkerObjectNameInfoEXT const &lhs,
                  VkDebugMarkerObjectNameInfoEXT const &rhs) noexcept;
  bool operator!=(VkDebugMarkerObjectNameInfoEXT const &lhs,
                  VkDebugMarkerObjectNameInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDebugMarkerObjectTagInfoEXT const &lhs,
                  VkDebugMarkerObjectTagInfoEXT const &rhs) noexcept;
  bool operator!=(VkDebugMarkerObjectTagInfoEXT const &lhs,
                  VkDebugMarkerObjectTagInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDebugMarkerMarkerInfoEXT const &lhs,
                  VkDebugMarkerMarkerInfoEXT const &rhs) noexcept;
  bool operator!=(VkDebugMarkerMarkerInfoEXT const &lhs,
                  VkDebugMarkerMarkerInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDedicatedAllocationImageCreateInfoNV const &lhs,
                  VkDedicatedAllocationImageCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkDedicatedAllocationImageCreateInfoNV const &lhs,
                  VkDedicatedAllocationImageCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkDedicatedAllocationBufferCreateInfoNV const &lhs,
                  VkDedicatedAllocationBufferCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkDedicatedAllocationBufferCreateInfoNV const &lhs,
                  VkDedicatedAllocationBufferCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkDedicatedAllocationMemoryAllocateInfoNV const &lhs,
                  VkDedicatedAllocationMemoryAllocateInfoNV const &rhs) noexcept;
  bool operator!=(VkDedicatedAllocationMemoryAllocateInfoNV const &lhs,
                  VkDedicatedAllocationMemoryAllocateInfoNV const &rhs) noexcept;
  
  bool operator==(VkExternalImageFormatPropertiesNV const &lhs,
                  VkExternalImageFormatPropertiesNV const &rhs) noexcept;
  bool operator!=(VkExternalImageFormatPropertiesNV const &lhs,
                  VkExternalImageFormatPropertiesNV const &rhs) noexcept;
  
  bool operator==(VkExternalMemoryImageCreateInfoNV const &lhs,
                  VkExternalMemoryImageCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkExternalMemoryImageCreateInfoNV const &lhs,
                  VkExternalMemoryImageCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkExportMemoryAllocateInfoNV const &lhs,
                  VkExportMemoryAllocateInfoNV const &rhs) noexcept;
  bool operator!=(VkExportMemoryAllocateInfoNV const &lhs,
                  VkExportMemoryAllocateInfoNV const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkImportMemoryWin32HandleInfoNV const &lhs,
                  VkImportMemoryWin32HandleInfoNV const &rhs) noexcept;
  bool operator!=(VkImportMemoryWin32HandleInfoNV const &lhs,
                  VkImportMemoryWin32HandleInfoNV const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkExportMemoryWin32HandleInfoNV const &lhs,
                  VkExportMemoryWin32HandleInfoNV const &rhs) noexcept;
  bool operator!=(VkExportMemoryWin32HandleInfoNV const &lhs,
                  VkExportMemoryWin32HandleInfoNV const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkWin32KeyedMutexAcquireReleaseInfoNV const &lhs,
                  VkWin32KeyedMutexAcquireReleaseInfoNV const &rhs) noexcept;
  bool operator!=(VkWin32KeyedMutexAcquireReleaseInfoNV const &lhs,
                  VkWin32KeyedMutexAcquireReleaseInfoNV const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkDeviceGeneratedCommandsFeaturesNVX const &lhs,
                  VkDeviceGeneratedCommandsFeaturesNVX const &rhs) noexcept;
  bool operator!=(VkDeviceGeneratedCommandsFeaturesNVX const &lhs,
                  VkDeviceGeneratedCommandsFeaturesNVX const &rhs) noexcept;
  
  bool operator==(VkDeviceGeneratedCommandsLimitsNVX const &lhs,
                  VkDeviceGeneratedCommandsLimitsNVX const &rhs) noexcept;
  bool operator!=(VkDeviceGeneratedCommandsLimitsNVX const &lhs,
                  VkDeviceGeneratedCommandsLimitsNVX const &rhs) noexcept;
  
  bool operator==(VkIndirectCommandsTokenNVX const &lhs,
                  VkIndirectCommandsTokenNVX const &rhs) noexcept;
  bool operator!=(VkIndirectCommandsTokenNVX const &lhs,
                  VkIndirectCommandsTokenNVX const &rhs) noexcept;
  
  bool operator==(VkIndirectCommandsLayoutTokenNVX const &lhs,
                  VkIndirectCommandsLayoutTokenNVX const &rhs) noexcept;
  bool operator!=(VkIndirectCommandsLayoutTokenNVX const &lhs,
                  VkIndirectCommandsLayoutTokenNVX const &rhs) noexcept;
  
  bool operator==(VkIndirectCommandsLayoutCreateInfoNVX const &lhs,
                  VkIndirectCommandsLayoutCreateInfoNVX const &rhs) noexcept;
  bool operator!=(VkIndirectCommandsLayoutCreateInfoNVX const &lhs,
                  VkIndirectCommandsLayoutCreateInfoNVX const &rhs) noexcept;
  
  bool operator==(VkCmdProcessCommandsInfoNVX const &lhs,
                  VkCmdProcessCommandsInfoNVX const &rhs) noexcept;
  bool operator!=(VkCmdProcessCommandsInfoNVX const &lhs,
                  VkCmdProcessCommandsInfoNVX const &rhs) noexcept;
  
  bool operator==(VkCmdReserveSpaceForCommandsInfoNVX const &lhs,
                  VkCmdReserveSpaceForCommandsInfoNVX const &rhs) noexcept;
  bool operator!=(VkCmdReserveSpaceForCommandsInfoNVX const &lhs,
                  VkCmdReserveSpaceForCommandsInfoNVX const &rhs) noexcept;
  
  bool operator==(VkObjectTableCreateInfoNVX const &lhs,
                  VkObjectTableCreateInfoNVX const &rhs) noexcept;
  bool operator!=(VkObjectTableCreateInfoNVX const &lhs,
                  VkObjectTableCreateInfoNVX const &rhs) noexcept;
  
  bool operator==(VkObjectTableEntryNVX const &lhs,
                  VkObjectTableEntryNVX const &rhs) noexcept;
  bool operator!=(VkObjectTableEntryNVX const &lhs,
                  VkObjectTableEntryNVX const &rhs) noexcept;
  
  bool operator==(VkObjectTablePipelineEntryNVX const &lhs,
                  VkObjectTablePipelineEntryNVX const &rhs) noexcept;
  bool operator!=(VkObjectTablePipelineEntryNVX const &lhs,
                  VkObjectTablePipelineEntryNVX const &rhs) noexcept;
  
  bool operator==(VkObjectTableDescriptorSetEntryNVX const &lhs,
                  VkObjectTableDescriptorSetEntryNVX const &rhs) noexcept;
  bool operator!=(VkObjectTableDescriptorSetEntryNVX const &lhs,
                  VkObjectTableDescriptorSetEntryNVX const &rhs) noexcept;
  
  bool operator==(VkObjectTableVertexBufferEntryNVX const &lhs,
                  VkObjectTableVertexBufferEntryNVX const &rhs) noexcept;
  bool operator!=(VkObjectTableVertexBufferEntryNVX const &lhs,
                  VkObjectTableVertexBufferEntryNVX const &rhs) noexcept;
  
  bool operator==(VkObjectTableIndexBufferEntryNVX const &lhs,
                  VkObjectTableIndexBufferEntryNVX const &rhs) noexcept;
  bool operator!=(VkObjectTableIndexBufferEntryNVX const &lhs,
                  VkObjectTableIndexBufferEntryNVX const &rhs) noexcept;
  
  bool operator==(VkObjectTablePushConstantEntryNVX const &lhs,
                  VkObjectTablePushConstantEntryNVX const &rhs) noexcept;
  bool operator!=(VkObjectTablePushConstantEntryNVX const &lhs,
                  VkObjectTablePushConstantEntryNVX const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceFeatures2 const &lhs,
                  VkPhysicalDeviceFeatures2 const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceFeatures2 const &lhs,
                  VkPhysicalDeviceFeatures2 const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceProperties2 const &lhs,
                  VkPhysicalDeviceProperties2 const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceProperties2 const &lhs,
                  VkPhysicalDeviceProperties2 const &rhs) noexcept;
  
  bool operator==(VkFormatProperties2 const &lhs,
                  VkFormatProperties2 const &rhs) noexcept;
  bool operator!=(VkFormatProperties2 const &lhs,
                  VkFormatProperties2 const &rhs) noexcept;
  
  bool operator==(VkImageFormatProperties2 const &lhs,
                  VkImageFormatProperties2 const &rhs) noexcept;
  bool operator!=(VkImageFormatProperties2 const &lhs,
                  VkImageFormatProperties2 const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceImageFormatInfo2 const &lhs,
                  VkPhysicalDeviceImageFormatInfo2 const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceImageFormatInfo2 const &lhs,
                  VkPhysicalDeviceImageFormatInfo2 const &rhs) noexcept;
  
  bool operator==(VkQueueFamilyProperties2 const &lhs,
                  VkQueueFamilyProperties2 const &rhs) noexcept;
  bool operator!=(VkQueueFamilyProperties2 const &lhs,
                  VkQueueFamilyProperties2 const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceMemoryProperties2 const &lhs,
                  VkPhysicalDeviceMemoryProperties2 const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceMemoryProperties2 const &lhs,
                  VkPhysicalDeviceMemoryProperties2 const &rhs) noexcept;
  
  bool operator==(VkSparseImageFormatProperties2 const &lhs,
                  VkSparseImageFormatProperties2 const &rhs) noexcept;
  bool operator!=(VkSparseImageFormatProperties2 const &lhs,
                  VkSparseImageFormatProperties2 const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceSparseImageFormatInfo2 const &lhs,
                  VkPhysicalDeviceSparseImageFormatInfo2 const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceSparseImageFormatInfo2 const &lhs,
                  VkPhysicalDeviceSparseImageFormatInfo2 const &rhs) noexcept;
  
  bool operator==(VkPhysicalDevicePushDescriptorPropertiesKHR const &lhs,
                  VkPhysicalDevicePushDescriptorPropertiesKHR const &rhs) noexcept;
  bool operator!=(VkPhysicalDevicePushDescriptorPropertiesKHR const &lhs,
                  VkPhysicalDevicePushDescriptorPropertiesKHR const &rhs) noexcept;
  
  bool operator==(VkConformanceVersionKHR const &lhs,
                  VkConformanceVersionKHR const &rhs) noexcept;
  bool operator!=(VkConformanceVersionKHR const &lhs,
                  VkConformanceVersionKHR const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceDriverPropertiesKHR const &lhs,
                  VkPhysicalDeviceDriverPropertiesKHR const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceDriverPropertiesKHR const &lhs,
                  VkPhysicalDeviceDriverPropertiesKHR const &rhs) noexcept;
  
  bool operator==(VkPresentRegionsKHR const &lhs,
                  VkPresentRegionsKHR const &rhs) noexcept;
  bool operator!=(VkPresentRegionsKHR const &lhs,
                  VkPresentRegionsKHR const &rhs) noexcept;
  
  bool operator==(VkPresentRegionKHR const &lhs,
                  VkPresentRegionKHR const &rhs) noexcept;
  bool operator!=(VkPresentRegionKHR const &lhs,
                  VkPresentRegionKHR const &rhs) noexcept;
  
  bool operator==(VkRectLayerKHR const &lhs,
                  VkRectLayerKHR const &rhs) noexcept;
  bool operator!=(VkRectLayerKHR const &lhs,
                  VkRectLayerKHR const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceVariablePointerFeatures const &lhs,
                  VkPhysicalDeviceVariablePointerFeatures const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceVariablePointerFeatures const &lhs,
                  VkPhysicalDeviceVariablePointerFeatures const &rhs) noexcept;
  
  bool operator==(VkExternalMemoryProperties const &lhs,
                  VkExternalMemoryProperties const &rhs) noexcept;
  bool operator!=(VkExternalMemoryProperties const &lhs,
                  VkExternalMemoryProperties const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceExternalImageFormatInfo const &lhs,
                  VkPhysicalDeviceExternalImageFormatInfo const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceExternalImageFormatInfo const &lhs,
                  VkPhysicalDeviceExternalImageFormatInfo const &rhs) noexcept;
  
  bool operator==(VkExternalImageFormatProperties const &lhs,
                  VkExternalImageFormatProperties const &rhs) noexcept;
  bool operator!=(VkExternalImageFormatProperties const &lhs,
                  VkExternalImageFormatProperties const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceExternalBufferInfo const &lhs,
                  VkPhysicalDeviceExternalBufferInfo const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceExternalBufferInfo const &lhs,
                  VkPhysicalDeviceExternalBufferInfo const &rhs) noexcept;
  
  bool operator==(VkExternalBufferProperties const &lhs,
                  VkExternalBufferProperties const &rhs) noexcept;
  bool operator!=(VkExternalBufferProperties const &lhs,
                  VkExternalBufferProperties const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceIDProperties const &lhs,
                  VkPhysicalDeviceIDProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceIDProperties const &lhs,
                  VkPhysicalDeviceIDProperties const &rhs) noexcept;
  
  bool operator==(VkExternalMemoryImageCreateInfo const &lhs,
                  VkExternalMemoryImageCreateInfo const &rhs) noexcept;
  bool operator!=(VkExternalMemoryImageCreateInfo const &lhs,
                  VkExternalMemoryImageCreateInfo const &rhs) noexcept;
  
  bool operator==(VkExternalMemoryBufferCreateInfo const &lhs,
                  VkExternalMemoryBufferCreateInfo const &rhs) noexcept;
  bool operator!=(VkExternalMemoryBufferCreateInfo const &lhs,
                  VkExternalMemoryBufferCreateInfo const &rhs) noexcept;
  
  bool operator==(VkExportMemoryAllocateInfo const &lhs,
                  VkExportMemoryAllocateInfo const &rhs) noexcept;
  bool operator!=(VkExportMemoryAllocateInfo const &lhs,
                  VkExportMemoryAllocateInfo const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkImportMemoryWin32HandleInfoKHR const &lhs,
                  VkImportMemoryWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkImportMemoryWin32HandleInfoKHR const &lhs,
                  VkImportMemoryWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkExportMemoryWin32HandleInfoKHR const &lhs,
                  VkExportMemoryWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkExportMemoryWin32HandleInfoKHR const &lhs,
                  VkExportMemoryWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkMemoryWin32HandlePropertiesKHR const &lhs,
                  VkMemoryWin32HandlePropertiesKHR const &rhs) noexcept;
  bool operator!=(VkMemoryWin32HandlePropertiesKHR const &lhs,
                  VkMemoryWin32HandlePropertiesKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkMemoryGetWin32HandleInfoKHR const &lhs,
                  VkMemoryGetWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkMemoryGetWin32HandleInfoKHR const &lhs,
                  VkMemoryGetWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkImportMemoryFdInfoKHR const &lhs,
                  VkImportMemoryFdInfoKHR const &rhs) noexcept;
  bool operator!=(VkImportMemoryFdInfoKHR const &lhs,
                  VkImportMemoryFdInfoKHR const &rhs) noexcept;
  
  bool operator==(VkMemoryFdPropertiesKHR const &lhs,
                  VkMemoryFdPropertiesKHR const &rhs) noexcept;
  bool operator!=(VkMemoryFdPropertiesKHR const &lhs,
                  VkMemoryFdPropertiesKHR const &rhs) noexcept;
  
  bool operator==(VkMemoryGetFdInfoKHR const &lhs,
                  VkMemoryGetFdInfoKHR const &rhs) noexcept;
  bool operator!=(VkMemoryGetFdInfoKHR const &lhs,
                  VkMemoryGetFdInfoKHR const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkWin32KeyedMutexAcquireReleaseInfoKHR const &lhs,
                  VkWin32KeyedMutexAcquireReleaseInfoKHR const &rhs) noexcept;
  bool operator!=(VkWin32KeyedMutexAcquireReleaseInfoKHR const &lhs,
                  VkWin32KeyedMutexAcquireReleaseInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkPhysicalDeviceExternalSemaphoreInfo const &lhs,
                  VkPhysicalDeviceExternalSemaphoreInfo const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceExternalSemaphoreInfo const &lhs,
                  VkPhysicalDeviceExternalSemaphoreInfo const &rhs) noexcept;
  
  bool operator==(VkExternalSemaphoreProperties const &lhs,
                  VkExternalSemaphoreProperties const &rhs) noexcept;
  bool operator!=(VkExternalSemaphoreProperties const &lhs,
                  VkExternalSemaphoreProperties const &rhs) noexcept;
  
  bool operator==(VkExportSemaphoreCreateInfo const &lhs,
                  VkExportSemaphoreCreateInfo const &rhs) noexcept;
  bool operator!=(VkExportSemaphoreCreateInfo const &lhs,
                  VkExportSemaphoreCreateInfo const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkImportSemaphoreWin32HandleInfoKHR const &lhs,
                  VkImportSemaphoreWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkImportSemaphoreWin32HandleInfoKHR const &lhs,
                  VkImportSemaphoreWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkExportSemaphoreWin32HandleInfoKHR const &lhs,
                  VkExportSemaphoreWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkExportSemaphoreWin32HandleInfoKHR const &lhs,
                  VkExportSemaphoreWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkD3D12FenceSubmitInfoKHR const &lhs,
                  VkD3D12FenceSubmitInfoKHR const &rhs) noexcept;
  bool operator!=(VkD3D12FenceSubmitInfoKHR const &lhs,
                  VkD3D12FenceSubmitInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkSemaphoreGetWin32HandleInfoKHR const &lhs,
                  VkSemaphoreGetWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkSemaphoreGetWin32HandleInfoKHR const &lhs,
                  VkSemaphoreGetWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkImportSemaphoreFdInfoKHR const &lhs,
                  VkImportSemaphoreFdInfoKHR const &rhs) noexcept;
  bool operator!=(VkImportSemaphoreFdInfoKHR const &lhs,
                  VkImportSemaphoreFdInfoKHR const &rhs) noexcept;
  
  bool operator==(VkSemaphoreGetFdInfoKHR const &lhs,
                  VkSemaphoreGetFdInfoKHR const &rhs) noexcept;
  bool operator!=(VkSemaphoreGetFdInfoKHR const &lhs,
                  VkSemaphoreGetFdInfoKHR const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceExternalFenceInfo const &lhs,
                  VkPhysicalDeviceExternalFenceInfo const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceExternalFenceInfo const &lhs,
                  VkPhysicalDeviceExternalFenceInfo const &rhs) noexcept;
  
  bool operator==(VkExternalFenceProperties const &lhs,
                  VkExternalFenceProperties const &rhs) noexcept;
  bool operator!=(VkExternalFenceProperties const &lhs,
                  VkExternalFenceProperties const &rhs) noexcept;
  
  bool operator==(VkExportFenceCreateInfo const &lhs,
                  VkExportFenceCreateInfo const &rhs) noexcept;
  bool operator!=(VkExportFenceCreateInfo const &lhs,
                  VkExportFenceCreateInfo const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkImportFenceWin32HandleInfoKHR const &lhs,
                  VkImportFenceWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkImportFenceWin32HandleInfoKHR const &lhs,
                  VkImportFenceWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkExportFenceWin32HandleInfoKHR const &lhs,
                  VkExportFenceWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkExportFenceWin32HandleInfoKHR const &lhs,
                  VkExportFenceWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkFenceGetWin32HandleInfoKHR const &lhs,
                  VkFenceGetWin32HandleInfoKHR const &rhs) noexcept;
  bool operator!=(VkFenceGetWin32HandleInfoKHR const &lhs,
                  VkFenceGetWin32HandleInfoKHR const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkImportFenceFdInfoKHR const &lhs,
                  VkImportFenceFdInfoKHR const &rhs) noexcept;
  bool operator!=(VkImportFenceFdInfoKHR const &lhs,
                  VkImportFenceFdInfoKHR const &rhs) noexcept;
  
  bool operator==(VkFenceGetFdInfoKHR const &lhs,
                  VkFenceGetFdInfoKHR const &rhs) noexcept;
  bool operator!=(VkFenceGetFdInfoKHR const &lhs,
                  VkFenceGetFdInfoKHR const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceMultiviewFeatures const &lhs,
                  VkPhysicalDeviceMultiviewFeatures const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceMultiviewFeatures const &lhs,
                  VkPhysicalDeviceMultiviewFeatures const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceMultiviewProperties const &lhs,
                  VkPhysicalDeviceMultiviewProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceMultiviewProperties const &lhs,
                  VkPhysicalDeviceMultiviewProperties const &rhs) noexcept;
  
  bool operator==(VkRenderPassMultiviewCreateInfo const &lhs,
                  VkRenderPassMultiviewCreateInfo const &rhs) noexcept;
  bool operator!=(VkRenderPassMultiviewCreateInfo const &lhs,
                  VkRenderPassMultiviewCreateInfo const &rhs) noexcept;
  
  bool operator==(VkSurfaceCapabilities2EXT const &lhs,
                  VkSurfaceCapabilities2EXT const &rhs) noexcept;
  bool operator!=(VkSurfaceCapabilities2EXT const &lhs,
                  VkSurfaceCapabilities2EXT const &rhs) noexcept;
  
  bool operator==(VkDisplayPowerInfoEXT const &lhs,
                  VkDisplayPowerInfoEXT const &rhs) noexcept;
  bool operator!=(VkDisplayPowerInfoEXT const &lhs,
                  VkDisplayPowerInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDeviceEventInfoEXT const &lhs,
                  VkDeviceEventInfoEXT const &rhs) noexcept;
  bool operator!=(VkDeviceEventInfoEXT const &lhs,
                  VkDeviceEventInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDisplayEventInfoEXT const &lhs,
                  VkDisplayEventInfoEXT const &rhs) noexcept;
  bool operator!=(VkDisplayEventInfoEXT const &lhs,
                  VkDisplayEventInfoEXT const &rhs) noexcept;
  
  bool operator==(VkSwapchainCounterCreateInfoEXT const &lhs,
                  VkSwapchainCounterCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkSwapchainCounterCreateInfoEXT const &lhs,
                  VkSwapchainCounterCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceGroupProperties const &lhs,
                  VkPhysicalDeviceGroupProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceGroupProperties const &lhs,
                  VkPhysicalDeviceGroupProperties const &rhs) noexcept;
  
  bool operator==(VkMemoryAllocateFlagsInfo const &lhs,
                  VkMemoryAllocateFlagsInfo const &rhs) noexcept;
  bool operator!=(VkMemoryAllocateFlagsInfo const &lhs,
                  VkMemoryAllocateFlagsInfo const &rhs) noexcept;
  
  bool operator==(VkBindBufferMemoryInfo const &lhs,
                  VkBindBufferMemoryInfo const &rhs) noexcept;
  bool operator!=(VkBindBufferMemoryInfo const &lhs,
                  VkBindBufferMemoryInfo const &rhs) noexcept;
  
  bool operator==(VkBindBufferMemoryDeviceGroupInfo const &lhs,
                  VkBindBufferMemoryDeviceGroupInfo const &rhs) noexcept;
  bool operator!=(VkBindBufferMemoryDeviceGroupInfo const &lhs,
                  VkBindBufferMemoryDeviceGroupInfo const &rhs) noexcept;
  
  bool operator==(VkBindImageMemoryInfo const &lhs,
                  VkBindImageMemoryInfo const &rhs) noexcept;
  bool operator!=(VkBindImageMemoryInfo const &lhs,
                  VkBindImageMemoryInfo const &rhs) noexcept;
  
  bool operator==(VkBindImageMemoryDeviceGroupInfo const &lhs,
                  VkBindImageMemoryDeviceGroupInfo const &rhs) noexcept;
  bool operator!=(VkBindImageMemoryDeviceGroupInfo const &lhs,
                  VkBindImageMemoryDeviceGroupInfo const &rhs) noexcept;
  
  bool operator==(VkDeviceGroupRenderPassBeginInfo const &lhs,
                  VkDeviceGroupRenderPassBeginInfo const &rhs) noexcept;
  bool operator!=(VkDeviceGroupRenderPassBeginInfo const &lhs,
                  VkDeviceGroupRenderPassBeginInfo const &rhs) noexcept;
  
  bool operator==(VkDeviceGroupCommandBufferBeginInfo const &lhs,
                  VkDeviceGroupCommandBufferBeginInfo const &rhs) noexcept;
  bool operator!=(VkDeviceGroupCommandBufferBeginInfo const &lhs,
                  VkDeviceGroupCommandBufferBeginInfo const &rhs) noexcept;
  
  bool operator==(VkDeviceGroupSubmitInfo const &lhs,
                  VkDeviceGroupSubmitInfo const &rhs) noexcept;
  bool operator!=(VkDeviceGroupSubmitInfo const &lhs,
                  VkDeviceGroupSubmitInfo const &rhs) noexcept;
  
  bool operator==(VkDeviceGroupBindSparseInfo const &lhs,
                  VkDeviceGroupBindSparseInfo const &rhs) noexcept;
  bool operator!=(VkDeviceGroupBindSparseInfo const &lhs,
                  VkDeviceGroupBindSparseInfo const &rhs) noexcept;
  
  bool operator==(VkDeviceGroupPresentCapabilitiesKHR const &lhs,
                  VkDeviceGroupPresentCapabilitiesKHR const &rhs) noexcept;
  bool operator!=(VkDeviceGroupPresentCapabilitiesKHR const &lhs,
                  VkDeviceGroupPresentCapabilitiesKHR const &rhs) noexcept;
  
  bool operator==(VkImageSwapchainCreateInfoKHR const &lhs,
                  VkImageSwapchainCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkImageSwapchainCreateInfoKHR const &lhs,
                  VkImageSwapchainCreateInfoKHR const &rhs) noexcept;
  
  bool operator==(VkBindImageMemorySwapchainInfoKHR const &lhs,
                  VkBindImageMemorySwapchainInfoKHR const &rhs) noexcept;
  bool operator!=(VkBindImageMemorySwapchainInfoKHR const &lhs,
                  VkBindImageMemorySwapchainInfoKHR const &rhs) noexcept;
  
  bool operator==(VkAcquireNextImageInfoKHR const &lhs,
                  VkAcquireNextImageInfoKHR const &rhs) noexcept;
  bool operator!=(VkAcquireNextImageInfoKHR const &lhs,
                  VkAcquireNextImageInfoKHR const &rhs) noexcept;
  
  bool operator==(VkDeviceGroupPresentInfoKHR const &lhs,
                  VkDeviceGroupPresentInfoKHR const &rhs) noexcept;
  bool operator!=(VkDeviceGroupPresentInfoKHR const &lhs,
                  VkDeviceGroupPresentInfoKHR const &rhs) noexcept;
  
  bool operator==(VkDeviceGroupDeviceCreateInfo const &lhs,
                  VkDeviceGroupDeviceCreateInfo const &rhs) noexcept;
  bool operator!=(VkDeviceGroupDeviceCreateInfo const &lhs,
                  VkDeviceGroupDeviceCreateInfo const &rhs) noexcept;
  
  bool operator==(VkDeviceGroupSwapchainCreateInfoKHR const &lhs,
                  VkDeviceGroupSwapchainCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkDeviceGroupSwapchainCreateInfoKHR const &lhs,
                  VkDeviceGroupSwapchainCreateInfoKHR const &rhs) noexcept;
  
  bool operator==(VkDescriptorUpdateTemplateEntry const &lhs,
                  VkDescriptorUpdateTemplateEntry const &rhs) noexcept;
  bool operator!=(VkDescriptorUpdateTemplateEntry const &lhs,
                  VkDescriptorUpdateTemplateEntry const &rhs) noexcept;
  
  bool operator==(VkDescriptorUpdateTemplateCreateInfo const &lhs,
                  VkDescriptorUpdateTemplateCreateInfo const &rhs) noexcept;
  bool operator!=(VkDescriptorUpdateTemplateCreateInfo const &lhs,
                  VkDescriptorUpdateTemplateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkXYColorEXT const &lhs,
                  VkXYColorEXT const &rhs) noexcept;
  bool operator!=(VkXYColorEXT const &lhs,
                  VkXYColorEXT const &rhs) noexcept;
  
  bool operator==(VkHdrMetadataEXT const &lhs,
                  VkHdrMetadataEXT const &rhs) noexcept;
  bool operator!=(VkHdrMetadataEXT const &lhs,
                  VkHdrMetadataEXT const &rhs) noexcept;
  
  bool operator==(VkRefreshCycleDurationGOOGLE const &lhs,
                  VkRefreshCycleDurationGOOGLE const &rhs) noexcept;
  bool operator!=(VkRefreshCycleDurationGOOGLE const &lhs,
                  VkRefreshCycleDurationGOOGLE const &rhs) noexcept;
  
  bool operator==(VkPastPresentationTimingGOOGLE const &lhs,
                  VkPastPresentationTimingGOOGLE const &rhs) noexcept;
  bool operator!=(VkPastPresentationTimingGOOGLE const &lhs,
                  VkPastPresentationTimingGOOGLE const &rhs) noexcept;
  
  bool operator==(VkPresentTimesInfoGOOGLE const &lhs,
                  VkPresentTimesInfoGOOGLE const &rhs) noexcept;
  bool operator!=(VkPresentTimesInfoGOOGLE const &lhs,
                  VkPresentTimesInfoGOOGLE const &rhs) noexcept;
  
  bool operator==(VkPresentTimeGOOGLE const &lhs,
                  VkPresentTimeGOOGLE const &rhs) noexcept;
  bool operator!=(VkPresentTimeGOOGLE const &lhs,
                  VkPresentTimeGOOGLE const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_IOS_MVK
  bool operator==(VkIOSSurfaceCreateInfoMVK const &lhs,
                  VkIOSSurfaceCreateInfoMVK const &rhs) noexcept;
  bool operator!=(VkIOSSurfaceCreateInfoMVK const &lhs,
                  VkIOSSurfaceCreateInfoMVK const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_IOS_MVK
  
  #ifdef VK_USE_PLATFORM_MACOS_MVK
  bool operator==(VkMacOSSurfaceCreateInfoMVK const &lhs,
                  VkMacOSSurfaceCreateInfoMVK const &rhs) noexcept;
  bool operator!=(VkMacOSSurfaceCreateInfoMVK const &lhs,
                  VkMacOSSurfaceCreateInfoMVK const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_MACOS_MVK
  
  bool operator==(VkViewportWScalingNV const &lhs,
                  VkViewportWScalingNV const &rhs) noexcept;
  bool operator!=(VkViewportWScalingNV const &lhs,
                  VkViewportWScalingNV const &rhs) noexcept;
  
  bool operator==(VkPipelineViewportWScalingStateCreateInfoNV const &lhs,
                  VkPipelineViewportWScalingStateCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkPipelineViewportWScalingStateCreateInfoNV const &lhs,
                  VkPipelineViewportWScalingStateCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkViewportSwizzleNV const &lhs,
                  VkViewportSwizzleNV const &rhs) noexcept;
  bool operator!=(VkViewportSwizzleNV const &lhs,
                  VkViewportSwizzleNV const &rhs) noexcept;
  
  bool operator==(VkPipelineViewportSwizzleStateCreateInfoNV const &lhs,
                  VkPipelineViewportSwizzleStateCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkPipelineViewportSwizzleStateCreateInfoNV const &lhs,
                  VkPipelineViewportSwizzleStateCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceDiscardRectanglePropertiesEXT const &lhs,
                  VkPhysicalDeviceDiscardRectanglePropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceDiscardRectanglePropertiesEXT const &lhs,
                  VkPhysicalDeviceDiscardRectanglePropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkPipelineDiscardRectangleStateCreateInfoEXT const &lhs,
                  VkPipelineDiscardRectangleStateCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkPipelineDiscardRectangleStateCreateInfoEXT const &lhs,
                  VkPipelineDiscardRectangleStateCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &lhs,
                  VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &lhs,
                  VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &rhs) noexcept;
  
  bool operator==(VkInputAttachmentAspectReference const &lhs,
                  VkInputAttachmentAspectReference const &rhs) noexcept;
  bool operator!=(VkInputAttachmentAspectReference const &lhs,
                  VkInputAttachmentAspectReference const &rhs) noexcept;
  
  bool operator==(VkRenderPassInputAttachmentAspectCreateInfo const &lhs,
                  VkRenderPassInputAttachmentAspectCreateInfo const &rhs) noexcept;
  bool operator!=(VkRenderPassInputAttachmentAspectCreateInfo const &lhs,
                  VkRenderPassInputAttachmentAspectCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceSurfaceInfo2KHR const &lhs,
                  VkPhysicalDeviceSurfaceInfo2KHR const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceSurfaceInfo2KHR const &lhs,
                  VkPhysicalDeviceSurfaceInfo2KHR const &rhs) noexcept;
  
  bool operator==(VkSurfaceCapabilities2KHR const &lhs,
                  VkSurfaceCapabilities2KHR const &rhs) noexcept;
  bool operator!=(VkSurfaceCapabilities2KHR const &lhs,
                  VkSurfaceCapabilities2KHR const &rhs) noexcept;
  
  bool operator==(VkSurfaceFormat2KHR const &lhs,
                  VkSurfaceFormat2KHR const &rhs) noexcept;
  bool operator!=(VkSurfaceFormat2KHR const &lhs,
                  VkSurfaceFormat2KHR const &rhs) noexcept;
  
  bool operator==(VkDisplayProperties2KHR const &lhs,
                  VkDisplayProperties2KHR const &rhs) noexcept;
  bool operator!=(VkDisplayProperties2KHR const &lhs,
                  VkDisplayProperties2KHR const &rhs) noexcept;
  
  bool operator==(VkDisplayPlaneProperties2KHR const &lhs,
                  VkDisplayPlaneProperties2KHR const &rhs) noexcept;
  bool operator!=(VkDisplayPlaneProperties2KHR const &lhs,
                  VkDisplayPlaneProperties2KHR const &rhs) noexcept;
  
  bool operator==(VkDisplayModeProperties2KHR const &lhs,
                  VkDisplayModeProperties2KHR const &rhs) noexcept;
  bool operator!=(VkDisplayModeProperties2KHR const &lhs,
                  VkDisplayModeProperties2KHR const &rhs) noexcept;
  
  bool operator==(VkDisplayPlaneInfo2KHR const &lhs,
                  VkDisplayPlaneInfo2KHR const &rhs) noexcept;
  bool operator!=(VkDisplayPlaneInfo2KHR const &lhs,
                  VkDisplayPlaneInfo2KHR const &rhs) noexcept;
  
  bool operator==(VkDisplayPlaneCapabilities2KHR const &lhs,
                  VkDisplayPlaneCapabilities2KHR const &rhs) noexcept;
  bool operator!=(VkDisplayPlaneCapabilities2KHR const &lhs,
                  VkDisplayPlaneCapabilities2KHR const &rhs) noexcept;
  
  bool operator==(VkSharedPresentSurfaceCapabilitiesKHR const &lhs,
                  VkSharedPresentSurfaceCapabilitiesKHR const &rhs) noexcept;
  bool operator!=(VkSharedPresentSurfaceCapabilitiesKHR const &lhs,
                  VkSharedPresentSurfaceCapabilitiesKHR const &rhs) noexcept;
  
  bool operator==(VkPhysicalDevice16BitStorageFeatures const &lhs,
                  VkPhysicalDevice16BitStorageFeatures const &rhs) noexcept;
  bool operator!=(VkPhysicalDevice16BitStorageFeatures const &lhs,
                  VkPhysicalDevice16BitStorageFeatures const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceSubgroupProperties const &lhs,
                  VkPhysicalDeviceSubgroupProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceSubgroupProperties const &lhs,
                  VkPhysicalDeviceSubgroupProperties const &rhs) noexcept;
  
  bool operator==(VkBufferMemoryRequirementsInfo2 const &lhs,
                  VkBufferMemoryRequirementsInfo2 const &rhs) noexcept;
  bool operator!=(VkBufferMemoryRequirementsInfo2 const &lhs,
                  VkBufferMemoryRequirementsInfo2 const &rhs) noexcept;
  
  bool operator==(VkImageMemoryRequirementsInfo2 const &lhs,
                  VkImageMemoryRequirementsInfo2 const &rhs) noexcept;
  bool operator!=(VkImageMemoryRequirementsInfo2 const &lhs,
                  VkImageMemoryRequirementsInfo2 const &rhs) noexcept;
  
  bool operator==(VkImageSparseMemoryRequirementsInfo2 const &lhs,
                  VkImageSparseMemoryRequirementsInfo2 const &rhs) noexcept;
  bool operator!=(VkImageSparseMemoryRequirementsInfo2 const &lhs,
                  VkImageSparseMemoryRequirementsInfo2 const &rhs) noexcept;
  
  bool operator==(VkMemoryRequirements2 const &lhs,
                  VkMemoryRequirements2 const &rhs) noexcept;
  bool operator!=(VkMemoryRequirements2 const &lhs,
                  VkMemoryRequirements2 const &rhs) noexcept;
  
  bool operator==(VkSparseImageMemoryRequirements2 const &lhs,
                  VkSparseImageMemoryRequirements2 const &rhs) noexcept;
  bool operator!=(VkSparseImageMemoryRequirements2 const &lhs,
                  VkSparseImageMemoryRequirements2 const &rhs) noexcept;
  
  bool operator==(VkPhysicalDevicePointClippingProperties const &lhs,
                  VkPhysicalDevicePointClippingProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDevicePointClippingProperties const &lhs,
                  VkPhysicalDevicePointClippingProperties const &rhs) noexcept;
  
  bool operator==(VkMemoryDedicatedRequirements const &lhs,
                  VkMemoryDedicatedRequirements const &rhs) noexcept;
  bool operator!=(VkMemoryDedicatedRequirements const &lhs,
                  VkMemoryDedicatedRequirements const &rhs) noexcept;
  
  bool operator==(VkMemoryDedicatedAllocateInfo const &lhs,
                  VkMemoryDedicatedAllocateInfo const &rhs) noexcept;
  bool operator!=(VkMemoryDedicatedAllocateInfo const &lhs,
                  VkMemoryDedicatedAllocateInfo const &rhs) noexcept;
  
  bool operator==(VkImageViewUsageCreateInfo const &lhs,
                  VkImageViewUsageCreateInfo const &rhs) noexcept;
  bool operator!=(VkImageViewUsageCreateInfo const &lhs,
                  VkImageViewUsageCreateInfo const &rhs) noexcept;
  
  bool operator==(VkPipelineTessellationDomainOriginStateCreateInfo const &lhs,
                  VkPipelineTessellationDomainOriginStateCreateInfo const &rhs) noexcept;
  bool operator!=(VkPipelineTessellationDomainOriginStateCreateInfo const &lhs,
                  VkPipelineTessellationDomainOriginStateCreateInfo const &rhs) noexcept;
  
  bool operator==(VkSamplerYcbcrConversionInfo const &lhs,
                  VkSamplerYcbcrConversionInfo const &rhs) noexcept;
  bool operator!=(VkSamplerYcbcrConversionInfo const &lhs,
                  VkSamplerYcbcrConversionInfo const &rhs) noexcept;
  
  bool operator==(VkSamplerYcbcrConversionCreateInfo const &lhs,
                  VkSamplerYcbcrConversionCreateInfo const &rhs) noexcept;
  bool operator!=(VkSamplerYcbcrConversionCreateInfo const &lhs,
                  VkSamplerYcbcrConversionCreateInfo const &rhs) noexcept;
  
  bool operator==(VkBindImagePlaneMemoryInfo const &lhs,
                  VkBindImagePlaneMemoryInfo const &rhs) noexcept;
  bool operator!=(VkBindImagePlaneMemoryInfo const &lhs,
                  VkBindImagePlaneMemoryInfo const &rhs) noexcept;
  
  bool operator==(VkImagePlaneMemoryRequirementsInfo const &lhs,
                  VkImagePlaneMemoryRequirementsInfo const &rhs) noexcept;
  bool operator!=(VkImagePlaneMemoryRequirementsInfo const &lhs,
                  VkImagePlaneMemoryRequirementsInfo const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceSamplerYcbcrConversionFeatures const &lhs,
                  VkPhysicalDeviceSamplerYcbcrConversionFeatures const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceSamplerYcbcrConversionFeatures const &lhs,
                  VkPhysicalDeviceSamplerYcbcrConversionFeatures const &rhs) noexcept;
  
  bool operator==(VkSamplerYcbcrConversionImageFormatProperties const &lhs,
                  VkSamplerYcbcrConversionImageFormatProperties const &rhs) noexcept;
  bool operator!=(VkSamplerYcbcrConversionImageFormatProperties const &lhs,
                  VkSamplerYcbcrConversionImageFormatProperties const &rhs) noexcept;
  
  bool operator==(VkTextureLODGatherFormatPropertiesAMD const &lhs,
                  VkTextureLODGatherFormatPropertiesAMD const &rhs) noexcept;
  bool operator!=(VkTextureLODGatherFormatPropertiesAMD const &lhs,
                  VkTextureLODGatherFormatPropertiesAMD const &rhs) noexcept;
  
  bool operator==(VkConditionalRenderingBeginInfoEXT const &lhs,
                  VkConditionalRenderingBeginInfoEXT const &rhs) noexcept;
  bool operator!=(VkConditionalRenderingBeginInfoEXT const &lhs,
                  VkConditionalRenderingBeginInfoEXT const &rhs) noexcept;
  
  bool operator==(VkProtectedSubmitInfo const &lhs,
                  VkProtectedSubmitInfo const &rhs) noexcept;
  bool operator!=(VkProtectedSubmitInfo const &lhs,
                  VkProtectedSubmitInfo const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceProtectedMemoryFeatures const &lhs,
                  VkPhysicalDeviceProtectedMemoryFeatures const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceProtectedMemoryFeatures const &lhs,
                  VkPhysicalDeviceProtectedMemoryFeatures const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceProtectedMemoryProperties const &lhs,
                  VkPhysicalDeviceProtectedMemoryProperties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceProtectedMemoryProperties const &lhs,
                  VkPhysicalDeviceProtectedMemoryProperties const &rhs) noexcept;
  
  bool operator==(VkDeviceQueueInfo2 const &lhs,
                  VkDeviceQueueInfo2 const &rhs) noexcept;
  bool operator!=(VkDeviceQueueInfo2 const &lhs,
                  VkDeviceQueueInfo2 const &rhs) noexcept;
  
  bool operator==(VkPipelineCoverageToColorStateCreateInfoNV const &lhs,
                  VkPipelineCoverageToColorStateCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkPipelineCoverageToColorStateCreateInfoNV const &lhs,
                  VkPipelineCoverageToColorStateCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &lhs,
                  VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &lhs,
                  VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkSampleLocationEXT const &lhs,
                  VkSampleLocationEXT const &rhs) noexcept;
  bool operator!=(VkSampleLocationEXT const &lhs,
                  VkSampleLocationEXT const &rhs) noexcept;
  
  bool operator==(VkSampleLocationsInfoEXT const &lhs,
                  VkSampleLocationsInfoEXT const &rhs) noexcept;
  bool operator!=(VkSampleLocationsInfoEXT const &lhs,
                  VkSampleLocationsInfoEXT const &rhs) noexcept;
  
  bool operator==(VkAttachmentSampleLocationsEXT const &lhs,
                  VkAttachmentSampleLocationsEXT const &rhs) noexcept;
  bool operator!=(VkAttachmentSampleLocationsEXT const &lhs,
                  VkAttachmentSampleLocationsEXT const &rhs) noexcept;
  
  bool operator==(VkSubpassSampleLocationsEXT const &lhs,
                  VkSubpassSampleLocationsEXT const &rhs) noexcept;
  bool operator!=(VkSubpassSampleLocationsEXT const &lhs,
                  VkSubpassSampleLocationsEXT const &rhs) noexcept;
  
  bool operator==(VkRenderPassSampleLocationsBeginInfoEXT const &lhs,
                  VkRenderPassSampleLocationsBeginInfoEXT const &rhs) noexcept;
  bool operator!=(VkRenderPassSampleLocationsBeginInfoEXT const &lhs,
                  VkRenderPassSampleLocationsBeginInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPipelineSampleLocationsStateCreateInfoEXT const &lhs,
                  VkPipelineSampleLocationsStateCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkPipelineSampleLocationsStateCreateInfoEXT const &lhs,
                  VkPipelineSampleLocationsStateCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceSampleLocationsPropertiesEXT const &lhs,
                  VkPhysicalDeviceSampleLocationsPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceSampleLocationsPropertiesEXT const &lhs,
                  VkPhysicalDeviceSampleLocationsPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkMultisamplePropertiesEXT const &lhs,
                  VkMultisamplePropertiesEXT const &rhs) noexcept;
  bool operator!=(VkMultisamplePropertiesEXT const &lhs,
                  VkMultisamplePropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkSamplerReductionModeCreateInfoEXT const &lhs,
                  VkSamplerReductionModeCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkSamplerReductionModeCreateInfoEXT const &lhs,
                  VkSamplerReductionModeCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &lhs,
                  VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &lhs,
                  VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &lhs,
                  VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &lhs,
                  VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkPipelineColorBlendAdvancedStateCreateInfoEXT const &lhs,
                  VkPipelineColorBlendAdvancedStateCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkPipelineColorBlendAdvancedStateCreateInfoEXT const &lhs,
                  VkPipelineColorBlendAdvancedStateCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &lhs,
                  VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &lhs,
                  VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &lhs,
                  VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &lhs,
                  VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkWriteDescriptorSetInlineUniformBlockEXT const &lhs,
                  VkWriteDescriptorSetInlineUniformBlockEXT const &rhs) noexcept;
  bool operator!=(VkWriteDescriptorSetInlineUniformBlockEXT const &lhs,
                  VkWriteDescriptorSetInlineUniformBlockEXT const &rhs) noexcept;
  
  bool operator==(VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &lhs,
                  VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &lhs,
                  VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPipelineCoverageModulationStateCreateInfoNV const &lhs,
                  VkPipelineCoverageModulationStateCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkPipelineCoverageModulationStateCreateInfoNV const &lhs,
                  VkPipelineCoverageModulationStateCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkImageFormatListCreateInfoKHR const &lhs,
                  VkImageFormatListCreateInfoKHR const &rhs) noexcept;
  bool operator!=(VkImageFormatListCreateInfoKHR const &lhs,
                  VkImageFormatListCreateInfoKHR const &rhs) noexcept;
  
  bool operator==(VkValidationCacheCreateInfoEXT const &lhs,
                  VkValidationCacheCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkValidationCacheCreateInfoEXT const &lhs,
                  VkValidationCacheCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkShaderModuleValidationCacheCreateInfoEXT const &lhs,
                  VkShaderModuleValidationCacheCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkShaderModuleValidationCacheCreateInfoEXT const &lhs,
                  VkShaderModuleValidationCacheCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceMaintenance3Properties const &lhs,
                  VkPhysicalDeviceMaintenance3Properties const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceMaintenance3Properties const &lhs,
                  VkPhysicalDeviceMaintenance3Properties const &rhs) noexcept;
  
  bool operator==(VkDescriptorSetLayoutSupport const &lhs,
                  VkDescriptorSetLayoutSupport const &rhs) noexcept;
  bool operator!=(VkDescriptorSetLayoutSupport const &lhs,
                  VkDescriptorSetLayoutSupport const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceShaderDrawParameterFeatures const &lhs,
                  VkPhysicalDeviceShaderDrawParameterFeatures const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceShaderDrawParameterFeatures const &lhs,
                  VkPhysicalDeviceShaderDrawParameterFeatures const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkNativeBufferANDROID const &lhs,
                  VkNativeBufferANDROID const &rhs) noexcept;
  bool operator!=(VkNativeBufferANDROID const &lhs,
                  VkNativeBufferANDROID const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  bool operator==(VkShaderResourceUsageAMD const &lhs,
                  VkShaderResourceUsageAMD const &rhs) noexcept;
  bool operator!=(VkShaderResourceUsageAMD const &lhs,
                  VkShaderResourceUsageAMD const &rhs) noexcept;
  
  bool operator==(VkShaderStatisticsInfoAMD const &lhs,
                  VkShaderStatisticsInfoAMD const &rhs) noexcept;
  bool operator!=(VkShaderStatisticsInfoAMD const &lhs,
                  VkShaderStatisticsInfoAMD const &rhs) noexcept;
  
  bool operator==(VkDeviceQueueGlobalPriorityCreateInfoEXT const &lhs,
                  VkDeviceQueueGlobalPriorityCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkDeviceQueueGlobalPriorityCreateInfoEXT const &lhs,
                  VkDeviceQueueGlobalPriorityCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDebugUtilsObjectNameInfoEXT const &lhs,
                  VkDebugUtilsObjectNameInfoEXT const &rhs) noexcept;
  bool operator!=(VkDebugUtilsObjectNameInfoEXT const &lhs,
                  VkDebugUtilsObjectNameInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDebugUtilsObjectTagInfoEXT const &lhs,
                  VkDebugUtilsObjectTagInfoEXT const &rhs) noexcept;
  bool operator!=(VkDebugUtilsObjectTagInfoEXT const &lhs,
                  VkDebugUtilsObjectTagInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDebugUtilsLabelEXT const &lhs,
                  VkDebugUtilsLabelEXT const &rhs) noexcept;
  bool operator!=(VkDebugUtilsLabelEXT const &lhs,
                  VkDebugUtilsLabelEXT const &rhs) noexcept;
  
  bool operator==(VkDebugUtilsMessengerCreateInfoEXT const &lhs,
                  VkDebugUtilsMessengerCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkDebugUtilsMessengerCreateInfoEXT const &lhs,
                  VkDebugUtilsMessengerCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDebugUtilsMessengerCallbackDataEXT const &lhs,
                  VkDebugUtilsMessengerCallbackDataEXT const &rhs) noexcept;
  bool operator!=(VkDebugUtilsMessengerCallbackDataEXT const &lhs,
                  VkDebugUtilsMessengerCallbackDataEXT const &rhs) noexcept;
  
  bool operator==(VkImportMemoryHostPointerInfoEXT const &lhs,
                  VkImportMemoryHostPointerInfoEXT const &rhs) noexcept;
  bool operator!=(VkImportMemoryHostPointerInfoEXT const &lhs,
                  VkImportMemoryHostPointerInfoEXT const &rhs) noexcept;
  
  bool operator==(VkMemoryHostPointerPropertiesEXT const &lhs,
                  VkMemoryHostPointerPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkMemoryHostPointerPropertiesEXT const &lhs,
                  VkMemoryHostPointerPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &lhs,
                  VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &lhs,
                  VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &lhs,
                  VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &lhs,
                  VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkCalibratedTimestampInfoEXT const &lhs,
                  VkCalibratedTimestampInfoEXT const &rhs) noexcept;
  bool operator!=(VkCalibratedTimestampInfoEXT const &lhs,
                  VkCalibratedTimestampInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceShaderCorePropertiesAMD const &lhs,
                  VkPhysicalDeviceShaderCorePropertiesAMD const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceShaderCorePropertiesAMD const &lhs,
                  VkPhysicalDeviceShaderCorePropertiesAMD const &rhs) noexcept;
  
  bool operator==(VkPipelineRasterizationConservativeStateCreateInfoEXT const &lhs,
                  VkPipelineRasterizationConservativeStateCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkPipelineRasterizationConservativeStateCreateInfoEXT const &lhs,
                  VkPipelineRasterizationConservativeStateCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &lhs,
                  VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &lhs,
                  VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceDescriptorIndexingPropertiesEXT const &lhs,
                  VkPhysicalDeviceDescriptorIndexingPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceDescriptorIndexingPropertiesEXT const &lhs,
                  VkPhysicalDeviceDescriptorIndexingPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &lhs,
                  VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &lhs,
                  VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &lhs,
                  VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &rhs) noexcept;
  bool operator!=(VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &lhs,
                  VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const &lhs,
                  VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const &rhs) noexcept;
  bool operator!=(VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const &lhs,
                  VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const &rhs) noexcept;
  
  bool operator==(VkAttachmentDescription2KHR const &lhs,
                  VkAttachmentDescription2KHR const &rhs) noexcept;
  bool operator!=(VkAttachmentDescription2KHR const &lhs,
                  VkAttachmentDescription2KHR const &rhs) noexcept;
  
  bool operator==(VkAttachmentReference2KHR const &lhs,
                  VkAttachmentReference2KHR const &rhs) noexcept;
  bool operator!=(VkAttachmentReference2KHR const &lhs,
                  VkAttachmentReference2KHR const &rhs) noexcept;
  
  bool operator==(VkSubpassDescription2KHR const &lhs,
                  VkSubpassDescription2KHR const &rhs) noexcept;
  bool operator!=(VkSubpassDescription2KHR const &lhs,
                  VkSubpassDescription2KHR const &rhs) noexcept;
  
  bool operator==(VkSubpassDependency2KHR const &lhs,
                  VkSubpassDependency2KHR const &rhs) noexcept;
  bool operator!=(VkSubpassDependency2KHR const &lhs,
                  VkSubpassDependency2KHR const &rhs) noexcept;
  
  bool operator==(VkRenderPassCreateInfo2KHR const &lhs,
                  VkRenderPassCreateInfo2KHR const &rhs) noexcept;
  bool operator!=(VkRenderPassCreateInfo2KHR const &lhs,
                  VkRenderPassCreateInfo2KHR const &rhs) noexcept;
  
  bool operator==(VkSubpassBeginInfoKHR const &lhs,
                  VkSubpassBeginInfoKHR const &rhs) noexcept;
  bool operator!=(VkSubpassBeginInfoKHR const &lhs,
                  VkSubpassBeginInfoKHR const &rhs) noexcept;
  
  bool operator==(VkSubpassEndInfoKHR const &lhs,
                  VkSubpassEndInfoKHR const &rhs) noexcept;
  bool operator!=(VkSubpassEndInfoKHR const &lhs,
                  VkSubpassEndInfoKHR const &rhs) noexcept;
  
  bool operator==(VkVertexInputBindingDivisorDescriptionEXT const &lhs,
                  VkVertexInputBindingDivisorDescriptionEXT const &rhs) noexcept;
  bool operator!=(VkVertexInputBindingDivisorDescriptionEXT const &lhs,
                  VkVertexInputBindingDivisorDescriptionEXT const &rhs) noexcept;
  
  bool operator==(VkPipelineVertexInputDivisorStateCreateInfoEXT const &lhs,
                  VkPipelineVertexInputDivisorStateCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkPipelineVertexInputDivisorStateCreateInfoEXT const &lhs,
                  VkPipelineVertexInputDivisorStateCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &lhs,
                  VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &lhs,
                  VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDevicePCIBusInfoPropertiesEXT const &lhs,
                  VkPhysicalDevicePCIBusInfoPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDevicePCIBusInfoPropertiesEXT const &lhs,
                  VkPhysicalDevicePCIBusInfoPropertiesEXT const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkImportAndroidHardwareBufferInfoANDROID const &lhs,
                  VkImportAndroidHardwareBufferInfoANDROID const &rhs) noexcept;
  bool operator!=(VkImportAndroidHardwareBufferInfoANDROID const &lhs,
                  VkImportAndroidHardwareBufferInfoANDROID const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkAndroidHardwareBufferUsageANDROID const &lhs,
                  VkAndroidHardwareBufferUsageANDROID const &rhs) noexcept;
  bool operator!=(VkAndroidHardwareBufferUsageANDROID const &lhs,
                  VkAndroidHardwareBufferUsageANDROID const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkAndroidHardwareBufferPropertiesANDROID const &lhs,
                  VkAndroidHardwareBufferPropertiesANDROID const &rhs) noexcept;
  bool operator!=(VkAndroidHardwareBufferPropertiesANDROID const &lhs,
                  VkAndroidHardwareBufferPropertiesANDROID const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkMemoryGetAndroidHardwareBufferInfoANDROID const &lhs,
                  VkMemoryGetAndroidHardwareBufferInfoANDROID const &rhs) noexcept;
  bool operator!=(VkMemoryGetAndroidHardwareBufferInfoANDROID const &lhs,
                  VkMemoryGetAndroidHardwareBufferInfoANDROID const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkAndroidHardwareBufferFormatPropertiesANDROID const &lhs,
                  VkAndroidHardwareBufferFormatPropertiesANDROID const &rhs) noexcept;
  bool operator!=(VkAndroidHardwareBufferFormatPropertiesANDROID const &lhs,
                  VkAndroidHardwareBufferFormatPropertiesANDROID const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  bool operator==(VkCommandBufferInheritanceConditionalRenderingInfoEXT const &lhs,
                  VkCommandBufferInheritanceConditionalRenderingInfoEXT const &rhs) noexcept;
  bool operator!=(VkCommandBufferInheritanceConditionalRenderingInfoEXT const &lhs,
                  VkCommandBufferInheritanceConditionalRenderingInfoEXT const &rhs) noexcept;
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkExternalFormatANDROID const &lhs,
                  VkExternalFormatANDROID const &rhs) noexcept;
  bool operator!=(VkExternalFormatANDROID const &lhs,
                  VkExternalFormatANDROID const &rhs) noexcept;
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  bool operator==(VkPhysicalDevice8BitStorageFeaturesKHR const &lhs,
                  VkPhysicalDevice8BitStorageFeaturesKHR const &rhs) noexcept;
  bool operator!=(VkPhysicalDevice8BitStorageFeaturesKHR const &lhs,
                  VkPhysicalDevice8BitStorageFeaturesKHR const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceConditionalRenderingFeaturesEXT const &lhs,
                  VkPhysicalDeviceConditionalRenderingFeaturesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceConditionalRenderingFeaturesEXT const &lhs,
                  VkPhysicalDeviceConditionalRenderingFeaturesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const &lhs,
                  VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const &lhs,
                  VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &lhs,
                  VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &lhs,
                  VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &lhs,
                  VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &lhs,
                  VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &rhs) noexcept;
  
  bool operator==(VkQueueFamilyCheckpointPropertiesNV const &lhs,
                  VkQueueFamilyCheckpointPropertiesNV const &rhs) noexcept;
  bool operator!=(VkQueueFamilyCheckpointPropertiesNV const &lhs,
                  VkQueueFamilyCheckpointPropertiesNV const &rhs) noexcept;
  
  bool operator==(VkCheckpointDataNV const &lhs,
                  VkCheckpointDataNV const &rhs) noexcept;
  bool operator!=(VkCheckpointDataNV const &lhs,
                  VkCheckpointDataNV const &rhs) noexcept;
  
  bool operator==(VkImageViewASTCDecodeModeEXT const &lhs,
                  VkImageViewASTCDecodeModeEXT const &rhs) noexcept;
  bool operator!=(VkImageViewASTCDecodeModeEXT const &lhs,
                  VkImageViewASTCDecodeModeEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceASTCDecodeFeaturesEXT const &lhs,
                  VkPhysicalDeviceASTCDecodeFeaturesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceASTCDecodeFeaturesEXT const &lhs,
                  VkPhysicalDeviceASTCDecodeFeaturesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceTransformFeedbackFeaturesEXT const &lhs,
                  VkPhysicalDeviceTransformFeedbackFeaturesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceTransformFeedbackFeaturesEXT const &lhs,
                  VkPhysicalDeviceTransformFeedbackFeaturesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceTransformFeedbackPropertiesEXT const &lhs,
                  VkPhysicalDeviceTransformFeedbackPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceTransformFeedbackPropertiesEXT const &lhs,
                  VkPhysicalDeviceTransformFeedbackPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkPipelineRasterizationStateStreamCreateInfoEXT const &lhs,
                  VkPipelineRasterizationStateStreamCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkPipelineRasterizationStateStreamCreateInfoEXT const &lhs,
                  VkPipelineRasterizationStateStreamCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &lhs,
                  VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &lhs,
                  VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &rhs) noexcept;
  
  bool operator==(VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &lhs,
                  VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &lhs,
                  VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceExclusiveScissorFeaturesNV const &lhs,
                  VkPhysicalDeviceExclusiveScissorFeaturesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceExclusiveScissorFeaturesNV const &lhs,
                  VkPhysicalDeviceExclusiveScissorFeaturesNV const &rhs) noexcept;
  
  bool operator==(VkPipelineViewportExclusiveScissorStateCreateInfoNV const &lhs,
                  VkPipelineViewportExclusiveScissorStateCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkPipelineViewportExclusiveScissorStateCreateInfoNV const &lhs,
                  VkPipelineViewportExclusiveScissorStateCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceCornerSampledImageFeaturesNV const &lhs,
                  VkPhysicalDeviceCornerSampledImageFeaturesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceCornerSampledImageFeaturesNV const &lhs,
                  VkPhysicalDeviceCornerSampledImageFeaturesNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &lhs,
                  VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &lhs,
                  VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &lhs,
                  VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &lhs,
                  VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceShaderImageFootprintFeaturesNV const &lhs,
                  VkPhysicalDeviceShaderImageFootprintFeaturesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceShaderImageFootprintFeaturesNV const &lhs,
                  VkPhysicalDeviceShaderImageFootprintFeaturesNV const &rhs) noexcept;
  
  bool operator==(VkShadingRatePaletteNV const &lhs,
                  VkShadingRatePaletteNV const &rhs) noexcept;
  bool operator!=(VkShadingRatePaletteNV const &lhs,
                  VkShadingRatePaletteNV const &rhs) noexcept;
  
  bool operator==(VkPipelineViewportShadingRateImageStateCreateInfoNV const &lhs,
                  VkPipelineViewportShadingRateImageStateCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkPipelineViewportShadingRateImageStateCreateInfoNV const &lhs,
                  VkPipelineViewportShadingRateImageStateCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceShadingRateImageFeaturesNV const &lhs,
                  VkPhysicalDeviceShadingRateImageFeaturesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceShadingRateImageFeaturesNV const &lhs,
                  VkPhysicalDeviceShadingRateImageFeaturesNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceShadingRateImagePropertiesNV const &lhs,
                  VkPhysicalDeviceShadingRateImagePropertiesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceShadingRateImagePropertiesNV const &lhs,
                  VkPhysicalDeviceShadingRateImagePropertiesNV const &rhs) noexcept;
  
  bool operator==(VkCoarseSampleLocationNV const &lhs,
                  VkCoarseSampleLocationNV const &rhs) noexcept;
  bool operator!=(VkCoarseSampleLocationNV const &lhs,
                  VkCoarseSampleLocationNV const &rhs) noexcept;
  
  bool operator==(VkCoarseSampleOrderCustomNV const &lhs,
                  VkCoarseSampleOrderCustomNV const &rhs) noexcept;
  bool operator!=(VkCoarseSampleOrderCustomNV const &lhs,
                  VkCoarseSampleOrderCustomNV const &rhs) noexcept;
  
  bool operator==(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &lhs,
                  VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &lhs,
                  VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceMeshShaderFeaturesNV const &lhs,
                  VkPhysicalDeviceMeshShaderFeaturesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceMeshShaderFeaturesNV const &lhs,
                  VkPhysicalDeviceMeshShaderFeaturesNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceMeshShaderPropertiesNV const &lhs,
                  VkPhysicalDeviceMeshShaderPropertiesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceMeshShaderPropertiesNV const &lhs,
                  VkPhysicalDeviceMeshShaderPropertiesNV const &rhs) noexcept;
  
  bool operator==(VkDrawMeshTasksIndirectCommandNV const &lhs,
                  VkDrawMeshTasksIndirectCommandNV const &rhs) noexcept;
  bool operator!=(VkDrawMeshTasksIndirectCommandNV const &lhs,
                  VkDrawMeshTasksIndirectCommandNV const &rhs) noexcept;
  
  bool operator==(VkRayTracingShaderGroupCreateInfoNV const &lhs,
                  VkRayTracingShaderGroupCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkRayTracingShaderGroupCreateInfoNV const &lhs,
                  VkRayTracingShaderGroupCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkRayTracingPipelineCreateInfoNV const &lhs,
                  VkRayTracingPipelineCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkRayTracingPipelineCreateInfoNV const &lhs,
                  VkRayTracingPipelineCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkGeometryTrianglesNV const &lhs,
                  VkGeometryTrianglesNV const &rhs) noexcept;
  bool operator!=(VkGeometryTrianglesNV const &lhs,
                  VkGeometryTrianglesNV const &rhs) noexcept;
  
  bool operator==(VkGeometryAABBNV const &lhs,
                  VkGeometryAABBNV const &rhs) noexcept;
  bool operator!=(VkGeometryAABBNV const &lhs,
                  VkGeometryAABBNV const &rhs) noexcept;
  
  bool operator==(VkGeometryDataNV const &lhs,
                  VkGeometryDataNV const &rhs) noexcept;
  bool operator!=(VkGeometryDataNV const &lhs,
                  VkGeometryDataNV const &rhs) noexcept;
  
  bool operator==(VkGeometryNV const &lhs,
                  VkGeometryNV const &rhs) noexcept;
  bool operator!=(VkGeometryNV const &lhs,
                  VkGeometryNV const &rhs) noexcept;
  
  bool operator==(VkAccelerationStructureInfoNV const &lhs,
                  VkAccelerationStructureInfoNV const &rhs) noexcept;
  bool operator!=(VkAccelerationStructureInfoNV const &lhs,
                  VkAccelerationStructureInfoNV const &rhs) noexcept;
  
  bool operator==(VkAccelerationStructureCreateInfoNV const &lhs,
                  VkAccelerationStructureCreateInfoNV const &rhs) noexcept;
  bool operator!=(VkAccelerationStructureCreateInfoNV const &lhs,
                  VkAccelerationStructureCreateInfoNV const &rhs) noexcept;
  
  bool operator==(VkBindAccelerationStructureMemoryInfoNV const &lhs,
                  VkBindAccelerationStructureMemoryInfoNV const &rhs) noexcept;
  bool operator!=(VkBindAccelerationStructureMemoryInfoNV const &lhs,
                  VkBindAccelerationStructureMemoryInfoNV const &rhs) noexcept;
  
  bool operator==(VkWriteDescriptorSetAccelerationStructureNV const &lhs,
                  VkWriteDescriptorSetAccelerationStructureNV const &rhs) noexcept;
  bool operator!=(VkWriteDescriptorSetAccelerationStructureNV const &lhs,
                  VkWriteDescriptorSetAccelerationStructureNV const &rhs) noexcept;
  
  bool operator==(VkAccelerationStructureMemoryRequirementsInfoNV const &lhs,
                  VkAccelerationStructureMemoryRequirementsInfoNV const &rhs) noexcept;
  bool operator!=(VkAccelerationStructureMemoryRequirementsInfoNV const &lhs,
                  VkAccelerationStructureMemoryRequirementsInfoNV const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceRayTracingPropertiesNV const &lhs,
                  VkPhysicalDeviceRayTracingPropertiesNV const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceRayTracingPropertiesNV const &lhs,
                  VkPhysicalDeviceRayTracingPropertiesNV const &rhs) noexcept;
  
  bool operator==(VkDrmFormatModifierPropertiesListEXT const &lhs,
                  VkDrmFormatModifierPropertiesListEXT const &rhs) noexcept;
  bool operator!=(VkDrmFormatModifierPropertiesListEXT const &lhs,
                  VkDrmFormatModifierPropertiesListEXT const &rhs) noexcept;
  
  bool operator==(VkDrmFormatModifierPropertiesEXT const &lhs,
                  VkDrmFormatModifierPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkDrmFormatModifierPropertiesEXT const &lhs,
                  VkDrmFormatModifierPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &lhs,
                  VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &rhs) noexcept;
  bool operator!=(VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &lhs,
                  VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &rhs) noexcept;
  
  bool operator==(VkImageDrmFormatModifierListCreateInfoEXT const &lhs,
                  VkImageDrmFormatModifierListCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkImageDrmFormatModifierListCreateInfoEXT const &lhs,
                  VkImageDrmFormatModifierListCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkImageDrmFormatModifierExplicitCreateInfoEXT const &lhs,
                  VkImageDrmFormatModifierExplicitCreateInfoEXT const &rhs) noexcept;
  bool operator!=(VkImageDrmFormatModifierExplicitCreateInfoEXT const &lhs,
                  VkImageDrmFormatModifierExplicitCreateInfoEXT const &rhs) noexcept;
  
  bool operator==(VkImageDrmFormatModifierPropertiesEXT const &lhs,
                  VkImageDrmFormatModifierPropertiesEXT const &rhs) noexcept;
  bool operator!=(VkImageDrmFormatModifierPropertiesEXT const &lhs,
                  VkImageDrmFormatModifierPropertiesEXT const &rhs) noexcept;
  
  bool operator==(VkDeviceMemoryOverallocationCreateInfoAMD const &lhs,
                  VkDeviceMemoryOverallocationCreateInfoAMD const &rhs) noexcept;
  bool operator!=(VkDeviceMemoryOverallocationCreateInfoAMD const &lhs,
                  VkDeviceMemoryOverallocationCreateInfoAMD const &rhs) noexcept;
  
  #ifdef VK_EQUALITY_CHECK_CONFIG_MAIN
  
  #include <cstdint>
  #include <cstring>
  
  bool operator==(VkBaseOutStructure const &lhs,
                  VkBaseOutStructure const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.pNext == rhs.pNext);
  }
  
  bool operator!=(VkBaseOutStructure const &lhs,
                  VkBaseOutStructure const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBaseInStructure const &lhs,
                  VkBaseInStructure const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.pNext == rhs.pNext);
  }
  
  bool operator!=(VkBaseInStructure const &lhs,
                  VkBaseInStructure const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkOffset2D const &lhs,
                  VkOffset2D const &rhs) noexcept {
    return (lhs.x == rhs.x) &&
           (lhs.y == rhs.y);
  }
  
  bool operator!=(VkOffset2D const &lhs,
                  VkOffset2D const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkOffset3D const &lhs,
                  VkOffset3D const &rhs) noexcept {
    return (lhs.x == rhs.x) &&
           (lhs.y == rhs.y) &&
           (lhs.z == rhs.z);
  }
  
  bool operator!=(VkOffset3D const &lhs,
                  VkOffset3D const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExtent2D const &lhs,
                  VkExtent2D const &rhs) noexcept {
    return (lhs.width == rhs.width) &&
           (lhs.height == rhs.height);
  }
  
  bool operator!=(VkExtent2D const &lhs,
                  VkExtent2D const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExtent3D const &lhs,
                  VkExtent3D const &rhs) noexcept {
    return (lhs.width == rhs.width) &&
           (lhs.height == rhs.height) &&
           (lhs.depth == rhs.depth);
  }
  
  bool operator!=(VkExtent3D const &lhs,
                  VkExtent3D const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkViewport const &lhs,
                  VkViewport const &rhs) noexcept {
    return (lhs.x == rhs.x) &&
           (lhs.y == rhs.y) &&
           (lhs.width == rhs.width) &&
           (lhs.height == rhs.height) &&
           (lhs.minDepth == rhs.minDepth) &&
           (lhs.maxDepth == rhs.maxDepth);
  }
  
  bool operator!=(VkViewport const &lhs,
                  VkViewport const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRect2D const &lhs,
                  VkRect2D const &rhs) noexcept {
    return (lhs.offset == rhs.offset) &&
           (lhs.extent == rhs.extent);
  }
  
  bool operator!=(VkRect2D const &lhs,
                  VkRect2D const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkClearRect const &lhs,
                  VkClearRect const &rhs) noexcept {
    return (lhs.rect == rhs.rect) &&
           (lhs.baseArrayLayer == rhs.baseArrayLayer) &&
           (lhs.layerCount == rhs.layerCount);
  }
  
  bool operator!=(VkClearRect const &lhs,
                  VkClearRect const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkComponentMapping const &lhs,
                  VkComponentMapping const &rhs) noexcept {
    return (lhs.r == rhs.r) &&
           (lhs.g == rhs.g) &&
           (lhs.b == rhs.b) &&
           (lhs.a == rhs.a);
  }
  
  bool operator!=(VkComponentMapping const &lhs,
                  VkComponentMapping const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceProperties const &lhs,
                  VkPhysicalDeviceProperties const &rhs) noexcept {
    for(uint32_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i) {
      if(lhs.deviceName[i] != rhs.deviceName[i])
        return false;
    }
  
    for(uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
      if(lhs.pipelineCacheUUID[i] != rhs.pipelineCacheUUID[i])
        return false;
    }
  
    return (lhs.apiVersion == rhs.apiVersion) &&
           (lhs.driverVersion == rhs.driverVersion) &&
           (lhs.vendorID == rhs.vendorID) &&
           (lhs.deviceID == rhs.deviceID) &&
           (lhs.deviceType == rhs.deviceType) &&
           (lhs.limits == rhs.limits) &&
           (lhs.sparseProperties == rhs.sparseProperties);
  }
  
  bool operator!=(VkPhysicalDeviceProperties const &lhs,
                  VkPhysicalDeviceProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExtensionProperties const &lhs,
                  VkExtensionProperties const &rhs) noexcept {
    for(uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
      if(lhs.extensionName[i] != rhs.extensionName[i])
        return false;
    }
  
    return (lhs.specVersion == rhs.specVersion);
  }
  
  bool operator!=(VkExtensionProperties const &lhs,
                  VkExtensionProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkLayerProperties const &lhs,
                  VkLayerProperties const &rhs) noexcept {
    for(uint32_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i) {
      if(lhs.layerName[i] != rhs.layerName[i])
        return false;
    }
  
    for(uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
      if(lhs.description[i] != rhs.description[i])
        return false;
    }
  
    return (lhs.specVersion == rhs.specVersion) &&
           (lhs.implementationVersion == rhs.implementationVersion);
  }
  
  bool operator!=(VkLayerProperties const &lhs,
                  VkLayerProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkApplicationInfo const &lhs,
                  VkApplicationInfo const &rhs) noexcept {
    if (lhs.pApplicationName != rhs.pApplicationName) {
      if(lhs.pApplicationName == nullptr || rhs.pApplicationName == nullptr)
        return false;
      if(strcmp(lhs.pApplicationName, rhs.pApplicationName) != 0)
        return false;
    }
  
    if (lhs.pEngineName != rhs.pEngineName) {
      if(lhs.pEngineName == nullptr || rhs.pEngineName == nullptr)
        return false;
      if(strcmp(lhs.pEngineName, rhs.pEngineName) != 0)
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.applicationVersion == rhs.applicationVersion) &&
           (lhs.engineVersion == rhs.engineVersion) &&
           (lhs.apiVersion == rhs.apiVersion);
  }
  
  bool operator!=(VkApplicationInfo const &lhs,
                  VkApplicationInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAllocationCallbacks const &lhs,
                  VkAllocationCallbacks const &rhs) noexcept {
    return (lhs.pUserData == rhs.pUserData) &&
           (lhs.pfnAllocation == rhs.pfnAllocation) &&
           (lhs.pfnReallocation == rhs.pfnReallocation) &&
           (lhs.pfnFree == rhs.pfnFree) &&
           (lhs.pfnInternalAllocation == rhs.pfnInternalAllocation) &&
           (lhs.pfnInternalFree == rhs.pfnInternalFree);
  }
  
  bool operator!=(VkAllocationCallbacks const &lhs,
                  VkAllocationCallbacks const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceQueueCreateInfo const &lhs,
                  VkDeviceQueueCreateInfo const &rhs) noexcept {
    if(lhs.queueCount != rhs.queueCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.queueCount; ++i) {
      if(lhs.pQueuePriorities[i] != rhs.pQueuePriorities[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.queueFamilyIndex == rhs.queueFamilyIndex);
  }
  
  bool operator!=(VkDeviceQueueCreateInfo const &lhs,
                  VkDeviceQueueCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkQueueFamilyProperties const &lhs,
                  VkQueueFamilyProperties const &rhs) noexcept {
    return (lhs.queueFlags == rhs.queueFlags) &&
           (lhs.queueCount == rhs.queueCount) &&
           (lhs.timestampValidBits == rhs.timestampValidBits) &&
           (lhs.minImageTransferGranularity == rhs.minImageTransferGranularity);
  }
  
  bool operator!=(VkQueueFamilyProperties const &lhs,
                  VkQueueFamilyProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceMemoryProperties const &lhs,
                  VkPhysicalDeviceMemoryProperties const &rhs) noexcept {
    for(uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i) {
      if(lhs.memoryTypes[i] != rhs.memoryTypes[i])
        return false;
    }
  
    for(uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
      if(lhs.memoryHeaps[i] != rhs.memoryHeaps[i])
        return false;
    }
  
    return (lhs.memoryTypeCount == rhs.memoryTypeCount) &&
           (lhs.memoryHeapCount == rhs.memoryHeapCount);
  }
  
  bool operator!=(VkPhysicalDeviceMemoryProperties const &lhs,
                  VkPhysicalDeviceMemoryProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryAllocateInfo const &lhs,
                  VkMemoryAllocateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.allocationSize == rhs.allocationSize) &&
           (lhs.memoryTypeIndex == rhs.memoryTypeIndex);
  }
  
  bool operator!=(VkMemoryAllocateInfo const &lhs,
                  VkMemoryAllocateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryRequirements const &lhs,
                  VkMemoryRequirements const &rhs) noexcept {
    return (lhs.size == rhs.size) &&
           (lhs.alignment == rhs.alignment) &&
           (lhs.memoryTypeBits == rhs.memoryTypeBits);
  }
  
  bool operator!=(VkMemoryRequirements const &lhs,
                  VkMemoryRequirements const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseImageFormatProperties const &lhs,
                  VkSparseImageFormatProperties const &rhs) noexcept {
    return (lhs.aspectMask == rhs.aspectMask) &&
           (lhs.imageGranularity == rhs.imageGranularity) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkSparseImageFormatProperties const &lhs,
                  VkSparseImageFormatProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseImageMemoryRequirements const &lhs,
                  VkSparseImageMemoryRequirements const &rhs) noexcept {
    return (lhs.formatProperties == rhs.formatProperties) &&
           (lhs.imageMipTailFirstLod == rhs.imageMipTailFirstLod) &&
           (lhs.imageMipTailSize == rhs.imageMipTailSize) &&
           (lhs.imageMipTailOffset == rhs.imageMipTailOffset) &&
           (lhs.imageMipTailStride == rhs.imageMipTailStride);
  }
  
  bool operator!=(VkSparseImageMemoryRequirements const &lhs,
                  VkSparseImageMemoryRequirements const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryType const &lhs,
                  VkMemoryType const &rhs) noexcept {
    return (lhs.propertyFlags == rhs.propertyFlags) &&
           (lhs.heapIndex == rhs.heapIndex);
  }
  
  bool operator!=(VkMemoryType const &lhs,
                  VkMemoryType const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryHeap const &lhs,
                  VkMemoryHeap const &rhs) noexcept {
    return (lhs.size == rhs.size) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkMemoryHeap const &lhs,
                  VkMemoryHeap const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMappedMemoryRange const &lhs,
                  VkMappedMemoryRange const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memory == rhs.memory) &&
           (lhs.offset == rhs.offset) &&
           (lhs.size == rhs.size);
  }
  
  bool operator!=(VkMappedMemoryRange const &lhs,
                  VkMappedMemoryRange const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkFormatProperties const &lhs,
                  VkFormatProperties const &rhs) noexcept {
    return (lhs.linearTilingFeatures == rhs.linearTilingFeatures) &&
           (lhs.optimalTilingFeatures == rhs.optimalTilingFeatures) &&
           (lhs.bufferFeatures == rhs.bufferFeatures);
  }
  
  bool operator!=(VkFormatProperties const &lhs,
                  VkFormatProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageFormatProperties const &lhs,
                  VkImageFormatProperties const &rhs) noexcept {
    return (lhs.maxExtent == rhs.maxExtent) &&
           (lhs.maxMipLevels == rhs.maxMipLevels) &&
           (lhs.maxArrayLayers == rhs.maxArrayLayers) &&
           (lhs.sampleCounts == rhs.sampleCounts) &&
           (lhs.maxResourceSize == rhs.maxResourceSize);
  }
  
  bool operator!=(VkImageFormatProperties const &lhs,
                  VkImageFormatProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorBufferInfo const &lhs,
                  VkDescriptorBufferInfo const &rhs) noexcept {
    return (lhs.buffer == rhs.buffer) &&
           (lhs.offset == rhs.offset) &&
           (lhs.range == rhs.range);
  }
  
  bool operator!=(VkDescriptorBufferInfo const &lhs,
                  VkDescriptorBufferInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorImageInfo const &lhs,
                  VkDescriptorImageInfo const &rhs) noexcept {
    return (lhs.sampler == rhs.sampler) &&
           (lhs.imageView == rhs.imageView) &&
           (lhs.imageLayout == rhs.imageLayout);
  }
  
  bool operator!=(VkDescriptorImageInfo const &lhs,
                  VkDescriptorImageInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkWriteDescriptorSet const &lhs,
                  VkWriteDescriptorSet const &rhs) noexcept {
    if(lhs.descriptorCount != rhs.descriptorCount)
      return false;
  
    if(lhs.descriptorCount != rhs.descriptorCount)
      return false;
  
    if(lhs.descriptorCount != rhs.descriptorCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.descriptorCount; ++i) {
      if(lhs.pImageInfo[i] != rhs.pImageInfo[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.descriptorCount; ++i) {
      if(lhs.pBufferInfo[i] != rhs.pBufferInfo[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.descriptorCount; ++i) {
      if(lhs.pTexelBufferView[i] != rhs.pTexelBufferView[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.dstSet == rhs.dstSet) &&
           (lhs.dstBinding == rhs.dstBinding) &&
           (lhs.dstArrayElement == rhs.dstArrayElement) &&
           (lhs.descriptorType == rhs.descriptorType);
  }
  
  bool operator!=(VkWriteDescriptorSet const &lhs,
                  VkWriteDescriptorSet const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCopyDescriptorSet const &lhs,
                  VkCopyDescriptorSet const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.srcSet == rhs.srcSet) &&
           (lhs.srcBinding == rhs.srcBinding) &&
           (lhs.srcArrayElement == rhs.srcArrayElement) &&
           (lhs.dstSet == rhs.dstSet) &&
           (lhs.dstBinding == rhs.dstBinding) &&
           (lhs.dstArrayElement == rhs.dstArrayElement) &&
           (lhs.descriptorCount == rhs.descriptorCount);
  }
  
  bool operator!=(VkCopyDescriptorSet const &lhs,
                  VkCopyDescriptorSet const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBufferCreateInfo const &lhs,
                  VkBufferCreateInfo const &rhs) noexcept {
    if(lhs.queueFamilyIndexCount != rhs.queueFamilyIndexCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.queueFamilyIndexCount; ++i) {
      if(lhs.pQueueFamilyIndices[i] != rhs.pQueueFamilyIndices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.size == rhs.size) &&
           (lhs.usage == rhs.usage) &&
           (lhs.sharingMode == rhs.sharingMode);
  }
  
  bool operator!=(VkBufferCreateInfo const &lhs,
                  VkBufferCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBufferViewCreateInfo const &lhs,
                  VkBufferViewCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.buffer == rhs.buffer) &&
           (lhs.format == rhs.format) &&
           (lhs.offset == rhs.offset) &&
           (lhs.range == rhs.range);
  }
  
  bool operator!=(VkBufferViewCreateInfo const &lhs,
                  VkBufferViewCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageSubresource const &lhs,
                  VkImageSubresource const &rhs) noexcept {
    return (lhs.aspectMask == rhs.aspectMask) &&
           (lhs.mipLevel == rhs.mipLevel) &&
           (lhs.arrayLayer == rhs.arrayLayer);
  }
  
  bool operator!=(VkImageSubresource const &lhs,
                  VkImageSubresource const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageSubresourceLayers const &lhs,
                  VkImageSubresourceLayers const &rhs) noexcept {
    return (lhs.aspectMask == rhs.aspectMask) &&
           (lhs.mipLevel == rhs.mipLevel) &&
           (lhs.baseArrayLayer == rhs.baseArrayLayer) &&
           (lhs.layerCount == rhs.layerCount);
  }
  
  bool operator!=(VkImageSubresourceLayers const &lhs,
                  VkImageSubresourceLayers const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageSubresourceRange const &lhs,
                  VkImageSubresourceRange const &rhs) noexcept {
    return (lhs.aspectMask == rhs.aspectMask) &&
           (lhs.baseMipLevel == rhs.baseMipLevel) &&
           (lhs.levelCount == rhs.levelCount) &&
           (lhs.baseArrayLayer == rhs.baseArrayLayer) &&
           (lhs.layerCount == rhs.layerCount);
  }
  
  bool operator!=(VkImageSubresourceRange const &lhs,
                  VkImageSubresourceRange const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryBarrier const &lhs,
                  VkMemoryBarrier const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.srcAccessMask == rhs.srcAccessMask) &&
           (lhs.dstAccessMask == rhs.dstAccessMask);
  }
  
  bool operator!=(VkMemoryBarrier const &lhs,
                  VkMemoryBarrier const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBufferMemoryBarrier const &lhs,
                  VkBufferMemoryBarrier const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.srcAccessMask == rhs.srcAccessMask) &&
           (lhs.dstAccessMask == rhs.dstAccessMask) &&
           (lhs.srcQueueFamilyIndex == rhs.srcQueueFamilyIndex) &&
           (lhs.dstQueueFamilyIndex == rhs.dstQueueFamilyIndex) &&
           (lhs.buffer == rhs.buffer) &&
           (lhs.offset == rhs.offset) &&
           (lhs.size == rhs.size);
  }
  
  bool operator!=(VkBufferMemoryBarrier const &lhs,
                  VkBufferMemoryBarrier const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageMemoryBarrier const &lhs,
                  VkImageMemoryBarrier const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.srcAccessMask == rhs.srcAccessMask) &&
           (lhs.dstAccessMask == rhs.dstAccessMask) &&
           (lhs.oldLayout == rhs.oldLayout) &&
           (lhs.newLayout == rhs.newLayout) &&
           (lhs.srcQueueFamilyIndex == rhs.srcQueueFamilyIndex) &&
           (lhs.dstQueueFamilyIndex == rhs.dstQueueFamilyIndex) &&
           (lhs.image == rhs.image) &&
           (lhs.subresourceRange == rhs.subresourceRange);
  }
  
  bool operator!=(VkImageMemoryBarrier const &lhs,
                  VkImageMemoryBarrier const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageCreateInfo const &lhs,
                  VkImageCreateInfo const &rhs) noexcept {
    if(lhs.queueFamilyIndexCount != rhs.queueFamilyIndexCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.queueFamilyIndexCount; ++i) {
      if(lhs.pQueueFamilyIndices[i] != rhs.pQueueFamilyIndices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.imageType == rhs.imageType) &&
           (lhs.format == rhs.format) &&
           (lhs.extent == rhs.extent) &&
           (lhs.mipLevels == rhs.mipLevels) &&
           (lhs.arrayLayers == rhs.arrayLayers) &&
           (lhs.samples == rhs.samples) &&
           (lhs.tiling == rhs.tiling) &&
           (lhs.usage == rhs.usage) &&
           (lhs.sharingMode == rhs.sharingMode) &&
           (lhs.initialLayout == rhs.initialLayout);
  }
  
  bool operator!=(VkImageCreateInfo const &lhs,
                  VkImageCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubresourceLayout const &lhs,
                  VkSubresourceLayout const &rhs) noexcept {
    return (lhs.offset == rhs.offset) &&
           (lhs.size == rhs.size) &&
           (lhs.rowPitch == rhs.rowPitch) &&
           (lhs.arrayPitch == rhs.arrayPitch) &&
           (lhs.depthPitch == rhs.depthPitch);
  }
  
  bool operator!=(VkSubresourceLayout const &lhs,
                  VkSubresourceLayout const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageViewCreateInfo const &lhs,
                  VkImageViewCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.image == rhs.image) &&
           (lhs.viewType == rhs.viewType) &&
           (lhs.format == rhs.format) &&
           (lhs.components == rhs.components) &&
           (lhs.subresourceRange == rhs.subresourceRange);
  }
  
  bool operator!=(VkImageViewCreateInfo const &lhs,
                  VkImageViewCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBufferCopy const &lhs,
                  VkBufferCopy const &rhs) noexcept {
    return (lhs.srcOffset == rhs.srcOffset) &&
           (lhs.dstOffset == rhs.dstOffset) &&
           (lhs.size == rhs.size);
  }
  
  bool operator!=(VkBufferCopy const &lhs,
                  VkBufferCopy const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseMemoryBind const &lhs,
                  VkSparseMemoryBind const &rhs) noexcept {
    return (lhs.resourceOffset == rhs.resourceOffset) &&
           (lhs.size == rhs.size) &&
           (lhs.memory == rhs.memory) &&
           (lhs.memoryOffset == rhs.memoryOffset) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkSparseMemoryBind const &lhs,
                  VkSparseMemoryBind const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseImageMemoryBind const &lhs,
                  VkSparseImageMemoryBind const &rhs) noexcept {
    return (lhs.subresource == rhs.subresource) &&
           (lhs.offset == rhs.offset) &&
           (lhs.extent == rhs.extent) &&
           (lhs.memory == rhs.memory) &&
           (lhs.memoryOffset == rhs.memoryOffset) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkSparseImageMemoryBind const &lhs,
                  VkSparseImageMemoryBind const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseBufferMemoryBindInfo const &lhs,
                  VkSparseBufferMemoryBindInfo const &rhs) noexcept {
    if(lhs.bindCount != rhs.bindCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.bindCount; ++i) {
      if(lhs.pBinds[i] != rhs.pBinds[i])
        return false;
    }
  
    return (lhs.buffer == rhs.buffer);
  }
  
  bool operator!=(VkSparseBufferMemoryBindInfo const &lhs,
                  VkSparseBufferMemoryBindInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseImageOpaqueMemoryBindInfo const &lhs,
                  VkSparseImageOpaqueMemoryBindInfo const &rhs) noexcept {
    if(lhs.bindCount != rhs.bindCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.bindCount; ++i) {
      if(lhs.pBinds[i] != rhs.pBinds[i])
        return false;
    }
  
    return (lhs.image == rhs.image);
  }
  
  bool operator!=(VkSparseImageOpaqueMemoryBindInfo const &lhs,
                  VkSparseImageOpaqueMemoryBindInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseImageMemoryBindInfo const &lhs,
                  VkSparseImageMemoryBindInfo const &rhs) noexcept {
    if(lhs.bindCount != rhs.bindCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.bindCount; ++i) {
      if(lhs.pBinds[i] != rhs.pBinds[i])
        return false;
    }
  
    return (lhs.image == rhs.image);
  }
  
  bool operator!=(VkSparseImageMemoryBindInfo const &lhs,
                  VkSparseImageMemoryBindInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBindSparseInfo const &lhs,
                  VkBindSparseInfo const &rhs) noexcept {
    if(lhs.waitSemaphoreCount != rhs.waitSemaphoreCount)
      return false;
  
    if(lhs.bufferBindCount != rhs.bufferBindCount)
      return false;
  
    if(lhs.imageOpaqueBindCount != rhs.imageOpaqueBindCount)
      return false;
  
    if(lhs.imageBindCount != rhs.imageBindCount)
      return false;
  
    if(lhs.signalSemaphoreCount != rhs.signalSemaphoreCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.waitSemaphoreCount; ++i) {
      if(lhs.pWaitSemaphores[i] != rhs.pWaitSemaphores[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.bufferBindCount; ++i) {
      if(lhs.pBufferBinds[i] != rhs.pBufferBinds[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.imageOpaqueBindCount; ++i) {
      if(lhs.pImageOpaqueBinds[i] != rhs.pImageOpaqueBinds[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.imageBindCount; ++i) {
      if(lhs.pImageBinds[i] != rhs.pImageBinds[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.signalSemaphoreCount; ++i) {
      if(lhs.pSignalSemaphores[i] != rhs.pSignalSemaphores[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkBindSparseInfo const &lhs,
                  VkBindSparseInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageCopy const &lhs,
                  VkImageCopy const &rhs) noexcept {
    return (lhs.srcSubresource == rhs.srcSubresource) &&
           (lhs.srcOffset == rhs.srcOffset) &&
           (lhs.dstSubresource == rhs.dstSubresource) &&
           (lhs.dstOffset == rhs.dstOffset) &&
           (lhs.extent == rhs.extent);
  }
  
  bool operator!=(VkImageCopy const &lhs,
                  VkImageCopy const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageBlit const &lhs,
                  VkImageBlit const &rhs) noexcept {
    for(uint32_t i = 0; i < 2; ++i) {
      if(lhs.srcOffsets[i] != rhs.srcOffsets[i])
        return false;
    }
  
    for(uint32_t i = 0; i < 2; ++i) {
      if(lhs.dstOffsets[i] != rhs.dstOffsets[i])
        return false;
    }
  
    return (lhs.srcSubresource == rhs.srcSubresource) &&
           (lhs.dstSubresource == rhs.dstSubresource);
  }
  
  bool operator!=(VkImageBlit const &lhs,
                  VkImageBlit const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBufferImageCopy const &lhs,
                  VkBufferImageCopy const &rhs) noexcept {
    return (lhs.bufferOffset == rhs.bufferOffset) &&
           (lhs.bufferRowLength == rhs.bufferRowLength) &&
           (lhs.bufferImageHeight == rhs.bufferImageHeight) &&
           (lhs.imageSubresource == rhs.imageSubresource) &&
           (lhs.imageOffset == rhs.imageOffset) &&
           (lhs.imageExtent == rhs.imageExtent);
  }
  
  bool operator!=(VkBufferImageCopy const &lhs,
                  VkBufferImageCopy const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageResolve const &lhs,
                  VkImageResolve const &rhs) noexcept {
    return (lhs.srcSubresource == rhs.srcSubresource) &&
           (lhs.srcOffset == rhs.srcOffset) &&
           (lhs.dstSubresource == rhs.dstSubresource) &&
           (lhs.dstOffset == rhs.dstOffset) &&
           (lhs.extent == rhs.extent);
  }
  
  bool operator!=(VkImageResolve const &lhs,
                  VkImageResolve const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkShaderModuleCreateInfo const &lhs,
                  VkShaderModuleCreateInfo const &rhs) noexcept {
    if(lhs.codeSize != rhs.codeSize)
      return false;
  
    for(uint32_t i = 0; i < lhs.codeSize / 4; ++i) {
      if(lhs.pCode[i] != rhs.pCode[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkShaderModuleCreateInfo const &lhs,
                  VkShaderModuleCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorSetLayoutBinding const &lhs,
                  VkDescriptorSetLayoutBinding const &rhs) noexcept {
    if(lhs.descriptorCount != rhs.descriptorCount)
      return false;
  
    if (lhs.pImmutableSamplers != rhs.pImmutableSamplers) {
      if(lhs.pImmutableSamplers == nullptr || rhs.pImmutableSamplers == nullptr)
        return false;
      for(uint32_t i = 0; i < lhs.descriptorCount; ++i) {
          if(lhs.pImmutableSamplers[i] != rhs.pImmutableSamplers[i])
          return false;
      }
    }
  
    return (lhs.binding == rhs.binding) &&
           (lhs.descriptorType == rhs.descriptorType) &&
           (lhs.stageFlags == rhs.stageFlags);
  }
  
  bool operator!=(VkDescriptorSetLayoutBinding const &lhs,
                  VkDescriptorSetLayoutBinding const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorSetLayoutCreateInfo const &lhs,
                  VkDescriptorSetLayoutCreateInfo const &rhs) noexcept {
    if(lhs.bindingCount != rhs.bindingCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.bindingCount; ++i) {
      if(lhs.pBindings[i] != rhs.pBindings[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkDescriptorSetLayoutCreateInfo const &lhs,
                  VkDescriptorSetLayoutCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorPoolSize const &lhs,
                  VkDescriptorPoolSize const &rhs) noexcept {
    return (lhs.type == rhs.type) &&
           (lhs.descriptorCount == rhs.descriptorCount);
  }
  
  bool operator!=(VkDescriptorPoolSize const &lhs,
                  VkDescriptorPoolSize const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorPoolCreateInfo const &lhs,
                  VkDescriptorPoolCreateInfo const &rhs) noexcept {
    if(lhs.poolSizeCount != rhs.poolSizeCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.poolSizeCount; ++i) {
      if(lhs.pPoolSizes[i] != rhs.pPoolSizes[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.maxSets == rhs.maxSets);
  }
  
  bool operator!=(VkDescriptorPoolCreateInfo const &lhs,
                  VkDescriptorPoolCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorSetAllocateInfo const &lhs,
                  VkDescriptorSetAllocateInfo const &rhs) noexcept {
    if(lhs.descriptorSetCount != rhs.descriptorSetCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.descriptorSetCount; ++i) {
      if(lhs.pSetLayouts[i] != rhs.pSetLayouts[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.descriptorPool == rhs.descriptorPool);
  }
  
  bool operator!=(VkDescriptorSetAllocateInfo const &lhs,
                  VkDescriptorSetAllocateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSpecializationMapEntry const &lhs,
                  VkSpecializationMapEntry const &rhs) noexcept {
    return (lhs.constantID == rhs.constantID) &&
           (lhs.offset == rhs.offset) &&
           (lhs.size == rhs.size);
  }
  
  bool operator!=(VkSpecializationMapEntry const &lhs,
                  VkSpecializationMapEntry const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSpecializationInfo const &lhs,
                  VkSpecializationInfo const &rhs) noexcept {
    if(lhs.mapEntryCount != rhs.mapEntryCount)
      return false;
  
    if(lhs.dataSize != rhs.dataSize)
      return false;
  
    for(uint32_t i = 0; i < lhs.mapEntryCount; ++i) {
      if(lhs.pMapEntries[i] != rhs.pMapEntries[i])
        return false;
    }
  
    if(memcmp(lhs.pData, rhs.pData, lhs.dataSize) != 0)
      return false;
  
    return true;
  }
  
  bool operator!=(VkSpecializationInfo const &lhs,
                  VkSpecializationInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineShaderStageCreateInfo const &lhs,
                  VkPipelineShaderStageCreateInfo const &rhs) noexcept {
    if (lhs.pName != rhs.pName) {
      if(lhs.pName == nullptr || rhs.pName == nullptr)
        return false;
      if(strcmp(lhs.pName, rhs.pName) != 0)
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.stage == rhs.stage) &&
           (lhs.module == rhs.module) &&
           (lhs.pSpecializationInfo == rhs.pSpecializationInfo);
  }
  
  bool operator!=(VkPipelineShaderStageCreateInfo const &lhs,
                  VkPipelineShaderStageCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkComputePipelineCreateInfo const &lhs,
                  VkComputePipelineCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.stage == rhs.stage) &&
           (lhs.layout == rhs.layout) &&
           (lhs.basePipelineHandle == rhs.basePipelineHandle) &&
           (lhs.basePipelineIndex == rhs.basePipelineIndex);
  }
  
  bool operator!=(VkComputePipelineCreateInfo const &lhs,
                  VkComputePipelineCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkVertexInputBindingDescription const &lhs,
                  VkVertexInputBindingDescription const &rhs) noexcept {
    return (lhs.binding == rhs.binding) &&
           (lhs.stride == rhs.stride) &&
           (lhs.inputRate == rhs.inputRate);
  }
  
  bool operator!=(VkVertexInputBindingDescription const &lhs,
                  VkVertexInputBindingDescription const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkVertexInputAttributeDescription const &lhs,
                  VkVertexInputAttributeDescription const &rhs) noexcept {
    return (lhs.location == rhs.location) &&
           (lhs.binding == rhs.binding) &&
           (lhs.format == rhs.format) &&
           (lhs.offset == rhs.offset);
  }
  
  bool operator!=(VkVertexInputAttributeDescription const &lhs,
                  VkVertexInputAttributeDescription const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineVertexInputStateCreateInfo const &lhs,
                  VkPipelineVertexInputStateCreateInfo const &rhs) noexcept {
    if(lhs.vertexBindingDescriptionCount != rhs.vertexBindingDescriptionCount)
      return false;
  
    if(lhs.vertexAttributeDescriptionCount != rhs.vertexAttributeDescriptionCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.vertexBindingDescriptionCount; ++i) {
      if(lhs.pVertexBindingDescriptions[i] != rhs.pVertexBindingDescriptions[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.vertexAttributeDescriptionCount; ++i) {
      if(lhs.pVertexAttributeDescriptions[i] != rhs.pVertexAttributeDescriptions[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkPipelineVertexInputStateCreateInfo const &lhs,
                  VkPipelineVertexInputStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineInputAssemblyStateCreateInfo const &lhs,
                  VkPipelineInputAssemblyStateCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.topology == rhs.topology) &&
           (lhs.primitiveRestartEnable == rhs.primitiveRestartEnable);
  }
  
  bool operator!=(VkPipelineInputAssemblyStateCreateInfo const &lhs,
                  VkPipelineInputAssemblyStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineTessellationStateCreateInfo const &lhs,
                  VkPipelineTessellationStateCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.patchControlPoints == rhs.patchControlPoints);
  }
  
  bool operator!=(VkPipelineTessellationStateCreateInfo const &lhs,
                  VkPipelineTessellationStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineViewportStateCreateInfo const &lhs,
                  VkPipelineViewportStateCreateInfo const &rhs) noexcept {
    if(lhs.viewportCount != rhs.viewportCount)
      return false;
  
    if(lhs.scissorCount != rhs.scissorCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.viewportCount; ++i) {
      if(lhs.pViewports[i] != rhs.pViewports[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.scissorCount; ++i) {
      if(lhs.pScissors[i] != rhs.pScissors[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkPipelineViewportStateCreateInfo const &lhs,
                  VkPipelineViewportStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineRasterizationStateCreateInfo const &lhs,
                  VkPipelineRasterizationStateCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.depthClampEnable == rhs.depthClampEnable) &&
           (lhs.rasterizerDiscardEnable == rhs.rasterizerDiscardEnable) &&
           (lhs.polygonMode == rhs.polygonMode) &&
           (lhs.cullMode == rhs.cullMode) &&
           (lhs.frontFace == rhs.frontFace) &&
           (lhs.depthBiasEnable == rhs.depthBiasEnable) &&
           (lhs.depthBiasConstantFactor == rhs.depthBiasConstantFactor) &&
           (lhs.depthBiasClamp == rhs.depthBiasClamp) &&
           (lhs.depthBiasSlopeFactor == rhs.depthBiasSlopeFactor) &&
           (lhs.lineWidth == rhs.lineWidth);
  }
  
  bool operator!=(VkPipelineRasterizationStateCreateInfo const &lhs,
                  VkPipelineRasterizationStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineMultisampleStateCreateInfo const &lhs,
                  VkPipelineMultisampleStateCreateInfo const &rhs) noexcept {
    if(lhs.rasterizationSamples != rhs.rasterizationSamples)
      return false;
  
    for(uint32_t i = 0; i < (lhs.rasterizationSamples + 31) / 32; ++i) {
      if(lhs.pSampleMask[i] != rhs.pSampleMask[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.sampleShadingEnable == rhs.sampleShadingEnable) &&
           (lhs.minSampleShading == rhs.minSampleShading) &&
           (lhs.alphaToCoverageEnable == rhs.alphaToCoverageEnable) &&
           (lhs.alphaToOneEnable == rhs.alphaToOneEnable);
  }
  
  bool operator!=(VkPipelineMultisampleStateCreateInfo const &lhs,
                  VkPipelineMultisampleStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineColorBlendAttachmentState const &lhs,
                  VkPipelineColorBlendAttachmentState const &rhs) noexcept {
    return (lhs.blendEnable == rhs.blendEnable) &&
           (lhs.srcColorBlendFactor == rhs.srcColorBlendFactor) &&
           (lhs.dstColorBlendFactor == rhs.dstColorBlendFactor) &&
           (lhs.colorBlendOp == rhs.colorBlendOp) &&
           (lhs.srcAlphaBlendFactor == rhs.srcAlphaBlendFactor) &&
           (lhs.dstAlphaBlendFactor == rhs.dstAlphaBlendFactor) &&
           (lhs.alphaBlendOp == rhs.alphaBlendOp) &&
           (lhs.colorWriteMask == rhs.colorWriteMask);
  }
  
  bool operator!=(VkPipelineColorBlendAttachmentState const &lhs,
                  VkPipelineColorBlendAttachmentState const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineColorBlendStateCreateInfo const &lhs,
                  VkPipelineColorBlendStateCreateInfo const &rhs) noexcept {
    if(lhs.attachmentCount != rhs.attachmentCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.attachmentCount; ++i) {
      if(lhs.pAttachments[i] != rhs.pAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < 4; ++i) {
      if(lhs.blendConstants[i] != rhs.blendConstants[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.logicOpEnable == rhs.logicOpEnable) &&
           (lhs.logicOp == rhs.logicOp);
  }
  
  bool operator!=(VkPipelineColorBlendStateCreateInfo const &lhs,
                  VkPipelineColorBlendStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineDynamicStateCreateInfo const &lhs,
                  VkPipelineDynamicStateCreateInfo const &rhs) noexcept {
    if(lhs.dynamicStateCount != rhs.dynamicStateCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.dynamicStateCount; ++i) {
      if(lhs.pDynamicStates[i] != rhs.pDynamicStates[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkPipelineDynamicStateCreateInfo const &lhs,
                  VkPipelineDynamicStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkStencilOpState const &lhs,
                  VkStencilOpState const &rhs) noexcept {
    return (lhs.failOp == rhs.failOp) &&
           (lhs.passOp == rhs.passOp) &&
           (lhs.depthFailOp == rhs.depthFailOp) &&
           (lhs.compareOp == rhs.compareOp) &&
           (lhs.compareMask == rhs.compareMask) &&
           (lhs.writeMask == rhs.writeMask) &&
           (lhs.reference == rhs.reference);
  }
  
  bool operator!=(VkStencilOpState const &lhs,
                  VkStencilOpState const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineDepthStencilStateCreateInfo const &lhs,
                  VkPipelineDepthStencilStateCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.depthTestEnable == rhs.depthTestEnable) &&
           (lhs.depthWriteEnable == rhs.depthWriteEnable) &&
           (lhs.depthCompareOp == rhs.depthCompareOp) &&
           (lhs.depthBoundsTestEnable == rhs.depthBoundsTestEnable) &&
           (lhs.stencilTestEnable == rhs.stencilTestEnable) &&
           (lhs.front == rhs.front) &&
           (lhs.back == rhs.back) &&
           (lhs.minDepthBounds == rhs.minDepthBounds) &&
           (lhs.maxDepthBounds == rhs.maxDepthBounds);
  }
  
  bool operator!=(VkPipelineDepthStencilStateCreateInfo const &lhs,
                  VkPipelineDepthStencilStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkGraphicsPipelineCreateInfo const &lhs,
                  VkGraphicsPipelineCreateInfo const &rhs) noexcept {
    if(lhs.stageCount != rhs.stageCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.stageCount; ++i) {
      if(lhs.pStages[i] != rhs.pStages[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pVertexInputState == rhs.pVertexInputState) &&
           (lhs.pInputAssemblyState == rhs.pInputAssemblyState) &&
           (lhs.pTessellationState == rhs.pTessellationState) &&
           (lhs.pViewportState == rhs.pViewportState) &&
           (lhs.pRasterizationState == rhs.pRasterizationState) &&
           (lhs.pMultisampleState == rhs.pMultisampleState) &&
           (lhs.pDepthStencilState == rhs.pDepthStencilState) &&
           (lhs.pColorBlendState == rhs.pColorBlendState) &&
           (lhs.pDynamicState == rhs.pDynamicState) &&
           (lhs.layout == rhs.layout) &&
           (lhs.renderPass == rhs.renderPass) &&
           (lhs.subpass == rhs.subpass) &&
           (lhs.basePipelineHandle == rhs.basePipelineHandle) &&
           (lhs.basePipelineIndex == rhs.basePipelineIndex);
  }
  
  bool operator!=(VkGraphicsPipelineCreateInfo const &lhs,
                  VkGraphicsPipelineCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineCacheCreateInfo const &lhs,
                  VkPipelineCacheCreateInfo const &rhs) noexcept {
    if(lhs.initialDataSize != rhs.initialDataSize)
      return false;
  
    if(memcmp(lhs.pInitialData, rhs.pInitialData, lhs.initialDataSize) != 0)
      return false;
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkPipelineCacheCreateInfo const &lhs,
                  VkPipelineCacheCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPushConstantRange const &lhs,
                  VkPushConstantRange const &rhs) noexcept {
    return (lhs.stageFlags == rhs.stageFlags) &&
           (lhs.offset == rhs.offset) &&
           (lhs.size == rhs.size);
  }
  
  bool operator!=(VkPushConstantRange const &lhs,
                  VkPushConstantRange const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineLayoutCreateInfo const &lhs,
                  VkPipelineLayoutCreateInfo const &rhs) noexcept {
    if(lhs.setLayoutCount != rhs.setLayoutCount)
      return false;
  
    if(lhs.pushConstantRangeCount != rhs.pushConstantRangeCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.setLayoutCount; ++i) {
      if(lhs.pSetLayouts[i] != rhs.pSetLayouts[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.pushConstantRangeCount; ++i) {
      if(lhs.pPushConstantRanges[i] != rhs.pPushConstantRanges[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkPipelineLayoutCreateInfo const &lhs,
                  VkPipelineLayoutCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSamplerCreateInfo const &lhs,
                  VkSamplerCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.magFilter == rhs.magFilter) &&
           (lhs.minFilter == rhs.minFilter) &&
           (lhs.mipmapMode == rhs.mipmapMode) &&
           (lhs.addressModeU == rhs.addressModeU) &&
           (lhs.addressModeV == rhs.addressModeV) &&
           (lhs.addressModeW == rhs.addressModeW) &&
           (lhs.mipLodBias == rhs.mipLodBias) &&
           (lhs.anisotropyEnable == rhs.anisotropyEnable) &&
           (lhs.maxAnisotropy == rhs.maxAnisotropy) &&
           (lhs.compareEnable == rhs.compareEnable) &&
           (lhs.compareOp == rhs.compareOp) &&
           (lhs.minLod == rhs.minLod) &&
           (lhs.maxLod == rhs.maxLod) &&
           (lhs.borderColor == rhs.borderColor) &&
           (lhs.unnormalizedCoordinates == rhs.unnormalizedCoordinates);
  }
  
  bool operator!=(VkSamplerCreateInfo const &lhs,
                  VkSamplerCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCommandPoolCreateInfo const &lhs,
                  VkCommandPoolCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.queueFamilyIndex == rhs.queueFamilyIndex);
  }
  
  bool operator!=(VkCommandPoolCreateInfo const &lhs,
                  VkCommandPoolCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCommandBufferAllocateInfo const &lhs,
                  VkCommandBufferAllocateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.commandPool == rhs.commandPool) &&
           (lhs.level == rhs.level) &&
           (lhs.commandBufferCount == rhs.commandBufferCount);
  }
  
  bool operator!=(VkCommandBufferAllocateInfo const &lhs,
                  VkCommandBufferAllocateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCommandBufferInheritanceInfo const &lhs,
                  VkCommandBufferInheritanceInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.renderPass == rhs.renderPass) &&
           (lhs.subpass == rhs.subpass) &&
           (lhs.framebuffer == rhs.framebuffer) &&
           (lhs.occlusionQueryEnable == rhs.occlusionQueryEnable) &&
           (lhs.queryFlags == rhs.queryFlags) &&
           (lhs.pipelineStatistics == rhs.pipelineStatistics);
  }
  
  bool operator!=(VkCommandBufferInheritanceInfo const &lhs,
                  VkCommandBufferInheritanceInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCommandBufferBeginInfo const &lhs,
                  VkCommandBufferBeginInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pInheritanceInfo == rhs.pInheritanceInfo);
  }
  
  bool operator!=(VkCommandBufferBeginInfo const &lhs,
                  VkCommandBufferBeginInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkClearDepthStencilValue const &lhs,
                  VkClearDepthStencilValue const &rhs) noexcept {
    return (lhs.depth == rhs.depth) &&
           (lhs.stencil == rhs.stencil);
  }
  
  bool operator!=(VkClearDepthStencilValue const &lhs,
                  VkClearDepthStencilValue const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAttachmentDescription const &lhs,
                  VkAttachmentDescription const &rhs) noexcept {
    return (lhs.flags == rhs.flags) &&
           (lhs.format == rhs.format) &&
           (lhs.samples == rhs.samples) &&
           (lhs.loadOp == rhs.loadOp) &&
           (lhs.storeOp == rhs.storeOp) &&
           (lhs.stencilLoadOp == rhs.stencilLoadOp) &&
           (lhs.stencilStoreOp == rhs.stencilStoreOp) &&
           (lhs.initialLayout == rhs.initialLayout) &&
           (lhs.finalLayout == rhs.finalLayout);
  }
  
  bool operator!=(VkAttachmentDescription const &lhs,
                  VkAttachmentDescription const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAttachmentReference const &lhs,
                  VkAttachmentReference const &rhs) noexcept {
    return (lhs.attachment == rhs.attachment) &&
           (lhs.layout == rhs.layout);
  }
  
  bool operator!=(VkAttachmentReference const &lhs,
                  VkAttachmentReference const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubpassDescription const &lhs,
                  VkSubpassDescription const &rhs) noexcept {
    if(lhs.inputAttachmentCount != rhs.inputAttachmentCount)
      return false;
  
    if(lhs.colorAttachmentCount != rhs.colorAttachmentCount)
      return false;
  
    if(lhs.colorAttachmentCount != rhs.colorAttachmentCount)
      return false;
  
    if(lhs.preserveAttachmentCount != rhs.preserveAttachmentCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.inputAttachmentCount; ++i) {
      if(lhs.pInputAttachments[i] != rhs.pInputAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.colorAttachmentCount; ++i) {
      if(lhs.pColorAttachments[i] != rhs.pColorAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.colorAttachmentCount; ++i) {
      if(lhs.pResolveAttachments[i] != rhs.pResolveAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.preserveAttachmentCount; ++i) {
      if(lhs.pPreserveAttachments[i] != rhs.pPreserveAttachments[i])
        return false;
    }
  
    return (lhs.flags == rhs.flags) &&
           (lhs.pipelineBindPoint == rhs.pipelineBindPoint) &&
           (lhs.pDepthStencilAttachment == rhs.pDepthStencilAttachment);
  }
  
  bool operator!=(VkSubpassDescription const &lhs,
                  VkSubpassDescription const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubpassDependency const &lhs,
                  VkSubpassDependency const &rhs) noexcept {
    return (lhs.srcSubpass == rhs.srcSubpass) &&
           (lhs.dstSubpass == rhs.dstSubpass) &&
           (lhs.srcStageMask == rhs.srcStageMask) &&
           (lhs.dstStageMask == rhs.dstStageMask) &&
           (lhs.srcAccessMask == rhs.srcAccessMask) &&
           (lhs.dstAccessMask == rhs.dstAccessMask) &&
           (lhs.dependencyFlags == rhs.dependencyFlags);
  }
  
  bool operator!=(VkSubpassDependency const &lhs,
                  VkSubpassDependency const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRenderPassCreateInfo const &lhs,
                  VkRenderPassCreateInfo const &rhs) noexcept {
    if(lhs.attachmentCount != rhs.attachmentCount)
      return false;
  
    if(lhs.subpassCount != rhs.subpassCount)
      return false;
  
    if(lhs.dependencyCount != rhs.dependencyCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.attachmentCount; ++i) {
      if(lhs.pAttachments[i] != rhs.pAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.subpassCount; ++i) {
      if(lhs.pSubpasses[i] != rhs.pSubpasses[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.dependencyCount; ++i) {
      if(lhs.pDependencies[i] != rhs.pDependencies[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkRenderPassCreateInfo const &lhs,
                  VkRenderPassCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkEventCreateInfo const &lhs,
                  VkEventCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkEventCreateInfo const &lhs,
                  VkEventCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkFenceCreateInfo const &lhs,
                  VkFenceCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkFenceCreateInfo const &lhs,
                  VkFenceCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceFeatures const &lhs,
                  VkPhysicalDeviceFeatures const &rhs) noexcept {
    return (lhs.robustBufferAccess == rhs.robustBufferAccess) &&
           (lhs.fullDrawIndexUint32 == rhs.fullDrawIndexUint32) &&
           (lhs.imageCubeArray == rhs.imageCubeArray) &&
           (lhs.independentBlend == rhs.independentBlend) &&
           (lhs.geometryShader == rhs.geometryShader) &&
           (lhs.tessellationShader == rhs.tessellationShader) &&
           (lhs.sampleRateShading == rhs.sampleRateShading) &&
           (lhs.dualSrcBlend == rhs.dualSrcBlend) &&
           (lhs.logicOp == rhs.logicOp) &&
           (lhs.multiDrawIndirect == rhs.multiDrawIndirect) &&
           (lhs.drawIndirectFirstInstance == rhs.drawIndirectFirstInstance) &&
           (lhs.depthClamp == rhs.depthClamp) &&
           (lhs.depthBiasClamp == rhs.depthBiasClamp) &&
           (lhs.fillModeNonSolid == rhs.fillModeNonSolid) &&
           (lhs.depthBounds == rhs.depthBounds) &&
           (lhs.wideLines == rhs.wideLines) &&
           (lhs.largePoints == rhs.largePoints) &&
           (lhs.alphaToOne == rhs.alphaToOne) &&
           (lhs.multiViewport == rhs.multiViewport) &&
           (lhs.samplerAnisotropy == rhs.samplerAnisotropy) &&
           (lhs.textureCompressionETC2 == rhs.textureCompressionETC2) &&
           (lhs.textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR) &&
           (lhs.textureCompressionBC == rhs.textureCompressionBC) &&
           (lhs.occlusionQueryPrecise == rhs.occlusionQueryPrecise) &&
           (lhs.pipelineStatisticsQuery == rhs.pipelineStatisticsQuery) &&
           (lhs.vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics) &&
           (lhs.fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics) &&
           (lhs.shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize) &&
           (lhs.shaderImageGatherExtended == rhs.shaderImageGatherExtended) &&
           (lhs.shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats) &&
           (lhs.shaderStorageImageMultisample == rhs.shaderStorageImageMultisample) &&
           (lhs.shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat) &&
           (lhs.shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat) &&
           (lhs.shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing) &&
           (lhs.shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing) &&
           (lhs.shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing) &&
           (lhs.shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing) &&
           (lhs.shaderClipDistance == rhs.shaderClipDistance) &&
           (lhs.shaderCullDistance == rhs.shaderCullDistance) &&
           (lhs.shaderFloat64 == rhs.shaderFloat64) &&
           (lhs.shaderInt64 == rhs.shaderInt64) &&
           (lhs.shaderInt16 == rhs.shaderInt16) &&
           (lhs.shaderResourceResidency == rhs.shaderResourceResidency) &&
           (lhs.shaderResourceMinLod == rhs.shaderResourceMinLod) &&
           (lhs.sparseBinding == rhs.sparseBinding) &&
           (lhs.sparseResidencyBuffer == rhs.sparseResidencyBuffer) &&
           (lhs.sparseResidencyImage2D == rhs.sparseResidencyImage2D) &&
           (lhs.sparseResidencyImage3D == rhs.sparseResidencyImage3D) &&
           (lhs.sparseResidency2Samples == rhs.sparseResidency2Samples) &&
           (lhs.sparseResidency4Samples == rhs.sparseResidency4Samples) &&
           (lhs.sparseResidency8Samples == rhs.sparseResidency8Samples) &&
           (lhs.sparseResidency16Samples == rhs.sparseResidency16Samples) &&
           (lhs.sparseResidencyAliased == rhs.sparseResidencyAliased) &&
           (lhs.variableMultisampleRate == rhs.variableMultisampleRate) &&
           (lhs.inheritedQueries == rhs.inheritedQueries);
  }
  
  bool operator!=(VkPhysicalDeviceFeatures const &lhs,
                  VkPhysicalDeviceFeatures const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceSparseProperties const &lhs,
                  VkPhysicalDeviceSparseProperties const &rhs) noexcept {
    return (lhs.residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape) &&
           (lhs.residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape) &&
           (lhs.residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape) &&
           (lhs.residencyAlignedMipSize == rhs.residencyAlignedMipSize) &&
           (lhs.residencyNonResidentStrict == rhs.residencyNonResidentStrict);
  }
  
  bool operator!=(VkPhysicalDeviceSparseProperties const &lhs,
                  VkPhysicalDeviceSparseProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceLimits const &lhs,
                  VkPhysicalDeviceLimits const &rhs) noexcept {
    for(uint32_t i = 0; i < 3; ++i) {
      if(lhs.maxComputeWorkGroupCount[i] != rhs.maxComputeWorkGroupCount[i])
        return false;
    }
  
    for(uint32_t i = 0; i < 3; ++i) {
      if(lhs.maxComputeWorkGroupSize[i] != rhs.maxComputeWorkGroupSize[i])
        return false;
    }
  
    for(uint32_t i = 0; i < 2; ++i) {
      if(lhs.maxViewportDimensions[i] != rhs.maxViewportDimensions[i])
        return false;
    }
  
    for(uint32_t i = 0; i < 2; ++i) {
      if(lhs.viewportBoundsRange[i] != rhs.viewportBoundsRange[i])
        return false;
    }
  
    for(uint32_t i = 0; i < 2; ++i) {
      if(lhs.pointSizeRange[i] != rhs.pointSizeRange[i])
        return false;
    }
  
    for(uint32_t i = 0; i < 2; ++i) {
      if(lhs.lineWidthRange[i] != rhs.lineWidthRange[i])
        return false;
    }
  
    return (lhs.maxImageDimension1D == rhs.maxImageDimension1D) &&
           (lhs.maxImageDimension2D == rhs.maxImageDimension2D) &&
           (lhs.maxImageDimension3D == rhs.maxImageDimension3D) &&
           (lhs.maxImageDimensionCube == rhs.maxImageDimensionCube) &&
           (lhs.maxImageArrayLayers == rhs.maxImageArrayLayers) &&
           (lhs.maxTexelBufferElements == rhs.maxTexelBufferElements) &&
           (lhs.maxUniformBufferRange == rhs.maxUniformBufferRange) &&
           (lhs.maxStorageBufferRange == rhs.maxStorageBufferRange) &&
           (lhs.maxPushConstantsSize == rhs.maxPushConstantsSize) &&
           (lhs.maxMemoryAllocationCount == rhs.maxMemoryAllocationCount) &&
           (lhs.maxSamplerAllocationCount == rhs.maxSamplerAllocationCount) &&
           (lhs.bufferImageGranularity == rhs.bufferImageGranularity) &&
           (lhs.sparseAddressSpaceSize == rhs.sparseAddressSpaceSize) &&
           (lhs.maxBoundDescriptorSets == rhs.maxBoundDescriptorSets) &&
           (lhs.maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers) &&
           (lhs.maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers) &&
           (lhs.maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers) &&
           (lhs.maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages) &&
           (lhs.maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages) &&
           (lhs.maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments) &&
           (lhs.maxPerStageResources == rhs.maxPerStageResources) &&
           (lhs.maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers) &&
           (lhs.maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers) &&
           (lhs.maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic) &&
           (lhs.maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers) &&
           (lhs.maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic) &&
           (lhs.maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages) &&
           (lhs.maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages) &&
           (lhs.maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments) &&
           (lhs.maxVertexInputAttributes == rhs.maxVertexInputAttributes) &&
           (lhs.maxVertexInputBindings == rhs.maxVertexInputBindings) &&
           (lhs.maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset) &&
           (lhs.maxVertexInputBindingStride == rhs.maxVertexInputBindingStride) &&
           (lhs.maxVertexOutputComponents == rhs.maxVertexOutputComponents) &&
           (lhs.maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel) &&
           (lhs.maxTessellationPatchSize == rhs.maxTessellationPatchSize) &&
           (lhs.maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents) &&
           (lhs.maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents) &&
           (lhs.maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents) &&
           (lhs.maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents) &&
           (lhs.maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents) &&
           (lhs.maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents) &&
           (lhs.maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations) &&
           (lhs.maxGeometryInputComponents == rhs.maxGeometryInputComponents) &&
           (lhs.maxGeometryOutputComponents == rhs.maxGeometryOutputComponents) &&
           (lhs.maxGeometryOutputVertices == rhs.maxGeometryOutputVertices) &&
           (lhs.maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents) &&
           (lhs.maxFragmentInputComponents == rhs.maxFragmentInputComponents) &&
           (lhs.maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments) &&
           (lhs.maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments) &&
           (lhs.maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources) &&
           (lhs.maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize) &&
           (lhs.maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations) &&
           (lhs.subPixelPrecisionBits == rhs.subPixelPrecisionBits) &&
           (lhs.subTexelPrecisionBits == rhs.subTexelPrecisionBits) &&
           (lhs.mipmapPrecisionBits == rhs.mipmapPrecisionBits) &&
           (lhs.maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue) &&
           (lhs.maxDrawIndirectCount == rhs.maxDrawIndirectCount) &&
           (lhs.maxSamplerLodBias == rhs.maxSamplerLodBias) &&
           (lhs.maxSamplerAnisotropy == rhs.maxSamplerAnisotropy) &&
           (lhs.maxViewports == rhs.maxViewports) &&
           (lhs.viewportSubPixelBits == rhs.viewportSubPixelBits) &&
           (lhs.minMemoryMapAlignment == rhs.minMemoryMapAlignment) &&
           (lhs.minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment) &&
           (lhs.minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment) &&
           (lhs.minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment) &&
           (lhs.minTexelOffset == rhs.minTexelOffset) &&
           (lhs.maxTexelOffset == rhs.maxTexelOffset) &&
           (lhs.minTexelGatherOffset == rhs.minTexelGatherOffset) &&
           (lhs.maxTexelGatherOffset == rhs.maxTexelGatherOffset) &&
           (lhs.minInterpolationOffset == rhs.minInterpolationOffset) &&
           (lhs.maxInterpolationOffset == rhs.maxInterpolationOffset) &&
           (lhs.subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits) &&
           (lhs.maxFramebufferWidth == rhs.maxFramebufferWidth) &&
           (lhs.maxFramebufferHeight == rhs.maxFramebufferHeight) &&
           (lhs.maxFramebufferLayers == rhs.maxFramebufferLayers) &&
           (lhs.framebufferColorSampleCounts == rhs.framebufferColorSampleCounts) &&
           (lhs.framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts) &&
           (lhs.framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts) &&
           (lhs.framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts) &&
           (lhs.maxColorAttachments == rhs.maxColorAttachments) &&
           (lhs.sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts) &&
           (lhs.sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts) &&
           (lhs.sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts) &&
           (lhs.sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts) &&
           (lhs.storageImageSampleCounts == rhs.storageImageSampleCounts) &&
           (lhs.maxSampleMaskWords == rhs.maxSampleMaskWords) &&
           (lhs.timestampComputeAndGraphics == rhs.timestampComputeAndGraphics) &&
           (lhs.timestampPeriod == rhs.timestampPeriod) &&
           (lhs.maxClipDistances == rhs.maxClipDistances) &&
           (lhs.maxCullDistances == rhs.maxCullDistances) &&
           (lhs.maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances) &&
           (lhs.discreteQueuePriorities == rhs.discreteQueuePriorities) &&
           (lhs.pointSizeGranularity == rhs.pointSizeGranularity) &&
           (lhs.lineWidthGranularity == rhs.lineWidthGranularity) &&
           (lhs.strictLines == rhs.strictLines) &&
           (lhs.standardSampleLocations == rhs.standardSampleLocations) &&
           (lhs.optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment) &&
           (lhs.optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment) &&
           (lhs.nonCoherentAtomSize == rhs.nonCoherentAtomSize);
  }
  
  bool operator!=(VkPhysicalDeviceLimits const &lhs,
                  VkPhysicalDeviceLimits const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSemaphoreCreateInfo const &lhs,
                  VkSemaphoreCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkSemaphoreCreateInfo const &lhs,
                  VkSemaphoreCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkQueryPoolCreateInfo const &lhs,
                  VkQueryPoolCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.queryType == rhs.queryType) &&
           (lhs.queryCount == rhs.queryCount) &&
           (lhs.pipelineStatistics == rhs.pipelineStatistics);
  }
  
  bool operator!=(VkQueryPoolCreateInfo const &lhs,
                  VkQueryPoolCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkFramebufferCreateInfo const &lhs,
                  VkFramebufferCreateInfo const &rhs) noexcept {
    if(lhs.attachmentCount != rhs.attachmentCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.attachmentCount; ++i) {
      if(lhs.pAttachments[i] != rhs.pAttachments[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.renderPass == rhs.renderPass) &&
           (lhs.width == rhs.width) &&
           (lhs.height == rhs.height) &&
           (lhs.layers == rhs.layers);
  }
  
  bool operator!=(VkFramebufferCreateInfo const &lhs,
                  VkFramebufferCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDrawIndirectCommand const &lhs,
                  VkDrawIndirectCommand const &rhs) noexcept {
    return (lhs.vertexCount == rhs.vertexCount) &&
           (lhs.instanceCount == rhs.instanceCount) &&
           (lhs.firstVertex == rhs.firstVertex) &&
           (lhs.firstInstance == rhs.firstInstance);
  }
  
  bool operator!=(VkDrawIndirectCommand const &lhs,
                  VkDrawIndirectCommand const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDrawIndexedIndirectCommand const &lhs,
                  VkDrawIndexedIndirectCommand const &rhs) noexcept {
    return (lhs.indexCount == rhs.indexCount) &&
           (lhs.instanceCount == rhs.instanceCount) &&
           (lhs.firstIndex == rhs.firstIndex) &&
           (lhs.vertexOffset == rhs.vertexOffset) &&
           (lhs.firstInstance == rhs.firstInstance);
  }
  
  bool operator!=(VkDrawIndexedIndirectCommand const &lhs,
                  VkDrawIndexedIndirectCommand const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDispatchIndirectCommand const &lhs,
                  VkDispatchIndirectCommand const &rhs) noexcept {
    return (lhs.x == rhs.x) &&
           (lhs.y == rhs.y) &&
           (lhs.z == rhs.z);
  }
  
  bool operator!=(VkDispatchIndirectCommand const &lhs,
                  VkDispatchIndirectCommand const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubmitInfo const &lhs,
                  VkSubmitInfo const &rhs) noexcept {
    if(lhs.waitSemaphoreCount != rhs.waitSemaphoreCount)
      return false;
  
    if(lhs.waitSemaphoreCount != rhs.waitSemaphoreCount)
      return false;
  
    if(lhs.commandBufferCount != rhs.commandBufferCount)
      return false;
  
    if(lhs.signalSemaphoreCount != rhs.signalSemaphoreCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.waitSemaphoreCount; ++i) {
      if(lhs.pWaitSemaphores[i] != rhs.pWaitSemaphores[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.waitSemaphoreCount; ++i) {
      if(lhs.pWaitDstStageMask[i] != rhs.pWaitDstStageMask[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.commandBufferCount; ++i) {
      if(lhs.pCommandBuffers[i] != rhs.pCommandBuffers[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.signalSemaphoreCount; ++i) {
      if(lhs.pSignalSemaphores[i] != rhs.pSignalSemaphores[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkSubmitInfo const &lhs,
                  VkSubmitInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayPropertiesKHR const &lhs,
                  VkDisplayPropertiesKHR const &rhs) noexcept {
    if (lhs.displayName != rhs.displayName) {
      if(lhs.displayName == nullptr || rhs.displayName == nullptr)
        return false;
      if(strcmp(lhs.displayName, rhs.displayName) != 0)
        return false;
    }
  
    return (lhs.display == rhs.display) &&
           (lhs.physicalDimensions == rhs.physicalDimensions) &&
           (lhs.physicalResolution == rhs.physicalResolution) &&
           (lhs.supportedTransforms == rhs.supportedTransforms) &&
           (lhs.planeReorderPossible == rhs.planeReorderPossible) &&
           (lhs.persistentContent == rhs.persistentContent);
  }
  
  bool operator!=(VkDisplayPropertiesKHR const &lhs,
                  VkDisplayPropertiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayPlanePropertiesKHR const &lhs,
                  VkDisplayPlanePropertiesKHR const &rhs) noexcept {
    return (lhs.currentDisplay == rhs.currentDisplay) &&
           (lhs.currentStackIndex == rhs.currentStackIndex);
  }
  
  bool operator!=(VkDisplayPlanePropertiesKHR const &lhs,
                  VkDisplayPlanePropertiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayModeParametersKHR const &lhs,
                  VkDisplayModeParametersKHR const &rhs) noexcept {
    return (lhs.visibleRegion == rhs.visibleRegion) &&
           (lhs.refreshRate == rhs.refreshRate);
  }
  
  bool operator!=(VkDisplayModeParametersKHR const &lhs,
                  VkDisplayModeParametersKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayModePropertiesKHR const &lhs,
                  VkDisplayModePropertiesKHR const &rhs) noexcept {
    return (lhs.displayMode == rhs.displayMode) &&
           (lhs.parameters == rhs.parameters);
  }
  
  bool operator!=(VkDisplayModePropertiesKHR const &lhs,
                  VkDisplayModePropertiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayModeCreateInfoKHR const &lhs,
                  VkDisplayModeCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.parameters == rhs.parameters);
  }
  
  bool operator!=(VkDisplayModeCreateInfoKHR const &lhs,
                  VkDisplayModeCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayPlaneCapabilitiesKHR const &lhs,
                  VkDisplayPlaneCapabilitiesKHR const &rhs) noexcept {
    return (lhs.supportedAlpha == rhs.supportedAlpha) &&
           (lhs.minSrcPosition == rhs.minSrcPosition) &&
           (lhs.maxSrcPosition == rhs.maxSrcPosition) &&
           (lhs.minSrcExtent == rhs.minSrcExtent) &&
           (lhs.maxSrcExtent == rhs.maxSrcExtent) &&
           (lhs.minDstPosition == rhs.minDstPosition) &&
           (lhs.maxDstPosition == rhs.maxDstPosition) &&
           (lhs.minDstExtent == rhs.minDstExtent) &&
           (lhs.maxDstExtent == rhs.maxDstExtent);
  }
  
  bool operator!=(VkDisplayPlaneCapabilitiesKHR const &lhs,
                  VkDisplayPlaneCapabilitiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplaySurfaceCreateInfoKHR const &lhs,
                  VkDisplaySurfaceCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.displayMode == rhs.displayMode) &&
           (lhs.planeIndex == rhs.planeIndex) &&
           (lhs.planeStackIndex == rhs.planeStackIndex) &&
           (lhs.transform == rhs.transform) &&
           (lhs.globalAlpha == rhs.globalAlpha) &&
           (lhs.alphaMode == rhs.alphaMode) &&
           (lhs.imageExtent == rhs.imageExtent);
  }
  
  bool operator!=(VkDisplaySurfaceCreateInfoKHR const &lhs,
                  VkDisplaySurfaceCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayPresentInfoKHR const &lhs,
                  VkDisplayPresentInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.srcRect == rhs.srcRect) &&
           (lhs.dstRect == rhs.dstRect) &&
           (lhs.persistent == rhs.persistent);
  }
  
  bool operator!=(VkDisplayPresentInfoKHR const &lhs,
                  VkDisplayPresentInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSurfaceCapabilitiesKHR const &lhs,
                  VkSurfaceCapabilitiesKHR const &rhs) noexcept {
    return (lhs.minImageCount == rhs.minImageCount) &&
           (lhs.maxImageCount == rhs.maxImageCount) &&
           (lhs.currentExtent == rhs.currentExtent) &&
           (lhs.minImageExtent == rhs.minImageExtent) &&
           (lhs.maxImageExtent == rhs.maxImageExtent) &&
           (lhs.maxImageArrayLayers == rhs.maxImageArrayLayers) &&
           (lhs.supportedTransforms == rhs.supportedTransforms) &&
           (lhs.currentTransform == rhs.currentTransform) &&
           (lhs.supportedCompositeAlpha == rhs.supportedCompositeAlpha) &&
           (lhs.supportedUsageFlags == rhs.supportedUsageFlags);
  }
  
  bool operator!=(VkSurfaceCapabilitiesKHR const &lhs,
                  VkSurfaceCapabilitiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkAndroidSurfaceCreateInfoKHR const &lhs,
                  VkAndroidSurfaceCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.window == rhs.window);
  }
  
  bool operator!=(VkAndroidSurfaceCreateInfoKHR const &lhs,
                  VkAndroidSurfaceCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_VI_NN
  bool operator==(VkViSurfaceCreateInfoNN const &lhs,
                  VkViSurfaceCreateInfoNN const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.window == rhs.window);
  }
  
  bool operator!=(VkViSurfaceCreateInfoNN const &lhs,
                  VkViSurfaceCreateInfoNN const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_VI_NN
  
  #ifdef VK_USE_PLATFORM_WAYLAND_KHR
  bool operator==(VkWaylandSurfaceCreateInfoKHR const &lhs,
                  VkWaylandSurfaceCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.display == rhs.display) &&
           (lhs.surface == rhs.surface);
  }
  
  bool operator!=(VkWaylandSurfaceCreateInfoKHR const &lhs,
                  VkWaylandSurfaceCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WAYLAND_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkWin32SurfaceCreateInfoKHR const &lhs,
                  VkWin32SurfaceCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.hinstance == rhs.hinstance) &&
           (lhs.hwnd == rhs.hwnd);
  }
  
  bool operator!=(VkWin32SurfaceCreateInfoKHR const &lhs,
                  VkWin32SurfaceCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_XLIB_KHR
  bool operator==(VkXlibSurfaceCreateInfoKHR const &lhs,
                  VkXlibSurfaceCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.dpy == rhs.dpy) &&
           (lhs.window == rhs.window);
  }
  
  bool operator!=(VkXlibSurfaceCreateInfoKHR const &lhs,
                  VkXlibSurfaceCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_XLIB_KHR
  
  #ifdef VK_USE_PLATFORM_XCB_KHR
  bool operator==(VkXcbSurfaceCreateInfoKHR const &lhs,
                  VkXcbSurfaceCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.connection == rhs.connection) &&
           (lhs.window == rhs.window);
  }
  
  bool operator!=(VkXcbSurfaceCreateInfoKHR const &lhs,
                  VkXcbSurfaceCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_XCB_KHR
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  bool operator==(VkImagePipeSurfaceCreateInfoFUCHSIA const &lhs,
                  VkImagePipeSurfaceCreateInfoFUCHSIA const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.imagePipeHandle == rhs.imagePipeHandle);
  }
  
  bool operator!=(VkImagePipeSurfaceCreateInfoFUCHSIA const &lhs,
                  VkImagePipeSurfaceCreateInfoFUCHSIA const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  bool operator==(VkSurfaceFormatKHR const &lhs,
                  VkSurfaceFormatKHR const &rhs) noexcept {
    return (lhs.format == rhs.format) &&
           (lhs.colorSpace == rhs.colorSpace);
  }
  
  bool operator!=(VkSurfaceFormatKHR const &lhs,
                  VkSurfaceFormatKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSwapchainCreateInfoKHR const &lhs,
                  VkSwapchainCreateInfoKHR const &rhs) noexcept {
    if(lhs.queueFamilyIndexCount != rhs.queueFamilyIndexCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.queueFamilyIndexCount; ++i) {
      if(lhs.pQueueFamilyIndices[i] != rhs.pQueueFamilyIndices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.surface == rhs.surface) &&
           (lhs.minImageCount == rhs.minImageCount) &&
           (lhs.imageFormat == rhs.imageFormat) &&
           (lhs.imageColorSpace == rhs.imageColorSpace) &&
           (lhs.imageExtent == rhs.imageExtent) &&
           (lhs.imageArrayLayers == rhs.imageArrayLayers) &&
           (lhs.imageUsage == rhs.imageUsage) &&
           (lhs.imageSharingMode == rhs.imageSharingMode) &&
           (lhs.preTransform == rhs.preTransform) &&
           (lhs.compositeAlpha == rhs.compositeAlpha) &&
           (lhs.presentMode == rhs.presentMode) &&
           (lhs.clipped == rhs.clipped) &&
           (lhs.oldSwapchain == rhs.oldSwapchain);
  }
  
  bool operator!=(VkSwapchainCreateInfoKHR const &lhs,
                  VkSwapchainCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPresentInfoKHR const &lhs,
                  VkPresentInfoKHR const &rhs) noexcept {
    if(lhs.waitSemaphoreCount != rhs.waitSemaphoreCount)
      return false;
  
    if(lhs.swapchainCount != rhs.swapchainCount)
      return false;
  
    if(lhs.swapchainCount != rhs.swapchainCount)
      return false;
  
    if(lhs.swapchainCount != rhs.swapchainCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.waitSemaphoreCount; ++i) {
      if(lhs.pWaitSemaphores[i] != rhs.pWaitSemaphores[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.swapchainCount; ++i) {
      if(lhs.pSwapchains[i] != rhs.pSwapchains[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.swapchainCount; ++i) {
      if(lhs.pImageIndices[i] != rhs.pImageIndices[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.swapchainCount; ++i) {
      if(lhs.pResults[i] != rhs.pResults[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkPresentInfoKHR const &lhs,
                  VkPresentInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugReportCallbackCreateInfoEXT const &lhs,
                  VkDebugReportCallbackCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pfnCallback == rhs.pfnCallback) &&
           (lhs.pUserData == rhs.pUserData);
  }
  
  bool operator!=(VkDebugReportCallbackCreateInfoEXT const &lhs,
                  VkDebugReportCallbackCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkValidationFlagsEXT const &lhs,
                  VkValidationFlagsEXT const &rhs) noexcept {
    if(lhs.disabledValidationCheckCount != rhs.disabledValidationCheckCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.disabledValidationCheckCount; ++i) {
      if(lhs.pDisabledValidationChecks[i] != rhs.pDisabledValidationChecks[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkValidationFlagsEXT const &lhs,
                  VkValidationFlagsEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineRasterizationStateRasterizationOrderAMD const &lhs,
                  VkPipelineRasterizationStateRasterizationOrderAMD const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.rasterizationOrder == rhs.rasterizationOrder);
  }
  
  bool operator!=(VkPipelineRasterizationStateRasterizationOrderAMD const &lhs,
                  VkPipelineRasterizationStateRasterizationOrderAMD const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugMarkerObjectNameInfoEXT const &lhs,
                  VkDebugMarkerObjectNameInfoEXT const &rhs) noexcept {
    if (lhs.pObjectName != rhs.pObjectName) {
      if(lhs.pObjectName == nullptr || rhs.pObjectName == nullptr)
        return false;
      if(strcmp(lhs.pObjectName, rhs.pObjectName) != 0)
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.objectType == rhs.objectType) &&
           (lhs.object == rhs.object);
  }
  
  bool operator!=(VkDebugMarkerObjectNameInfoEXT const &lhs,
                  VkDebugMarkerObjectNameInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugMarkerObjectTagInfoEXT const &lhs,
                  VkDebugMarkerObjectTagInfoEXT const &rhs) noexcept {
    if(lhs.tagSize != rhs.tagSize)
      return false;
  
    if(memcmp(lhs.pTag, rhs.pTag, lhs.tagSize) != 0)
      return false;
  
    return (lhs.sType == rhs.sType) &&
           (lhs.objectType == rhs.objectType) &&
           (lhs.object == rhs.object) &&
           (lhs.tagName == rhs.tagName);
  }
  
  bool operator!=(VkDebugMarkerObjectTagInfoEXT const &lhs,
                  VkDebugMarkerObjectTagInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugMarkerMarkerInfoEXT const &lhs,
                  VkDebugMarkerMarkerInfoEXT const &rhs) noexcept {
    if (lhs.pMarkerName != rhs.pMarkerName) {
      if(lhs.pMarkerName == nullptr || rhs.pMarkerName == nullptr)
        return false;
      if(strcmp(lhs.pMarkerName, rhs.pMarkerName) != 0)
        return false;
    }
  
    for(uint32_t i = 0; i < 4; ++i) {
      if(lhs.color[i] != rhs.color[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkDebugMarkerMarkerInfoEXT const &lhs,
                  VkDebugMarkerMarkerInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDedicatedAllocationImageCreateInfoNV const &lhs,
                  VkDedicatedAllocationImageCreateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.dedicatedAllocation == rhs.dedicatedAllocation);
  }
  
  bool operator!=(VkDedicatedAllocationImageCreateInfoNV const &lhs,
                  VkDedicatedAllocationImageCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDedicatedAllocationBufferCreateInfoNV const &lhs,
                  VkDedicatedAllocationBufferCreateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.dedicatedAllocation == rhs.dedicatedAllocation);
  }
  
  bool operator!=(VkDedicatedAllocationBufferCreateInfoNV const &lhs,
                  VkDedicatedAllocationBufferCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDedicatedAllocationMemoryAllocateInfoNV const &lhs,
                  VkDedicatedAllocationMemoryAllocateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.image == rhs.image) &&
           (lhs.buffer == rhs.buffer);
  }
  
  bool operator!=(VkDedicatedAllocationMemoryAllocateInfoNV const &lhs,
                  VkDedicatedAllocationMemoryAllocateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalImageFormatPropertiesNV const &lhs,
                  VkExternalImageFormatPropertiesNV const &rhs) noexcept {
    return (lhs.imageFormatProperties == rhs.imageFormatProperties) &&
           (lhs.externalMemoryFeatures == rhs.externalMemoryFeatures) &&
           (lhs.exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes) &&
           (lhs.compatibleHandleTypes == rhs.compatibleHandleTypes);
  }
  
  bool operator!=(VkExternalImageFormatPropertiesNV const &lhs,
                  VkExternalImageFormatPropertiesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalMemoryImageCreateInfoNV const &lhs,
                  VkExternalMemoryImageCreateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleTypes == rhs.handleTypes);
  }
  
  bool operator!=(VkExternalMemoryImageCreateInfoNV const &lhs,
                  VkExternalMemoryImageCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExportMemoryAllocateInfoNV const &lhs,
                  VkExportMemoryAllocateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleTypes == rhs.handleTypes);
  }
  
  bool operator!=(VkExportMemoryAllocateInfoNV const &lhs,
                  VkExportMemoryAllocateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkImportMemoryWin32HandleInfoNV const &lhs,
                  VkImportMemoryWin32HandleInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleType == rhs.handleType) &&
           (lhs.handle == rhs.handle);
  }
  
  bool operator!=(VkImportMemoryWin32HandleInfoNV const &lhs,
                  VkImportMemoryWin32HandleInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkExportMemoryWin32HandleInfoNV const &lhs,
                  VkExportMemoryWin32HandleInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.pAttributes == rhs.pAttributes) &&
           (lhs.dwAccess == rhs.dwAccess);
  }
  
  bool operator!=(VkExportMemoryWin32HandleInfoNV const &lhs,
                  VkExportMemoryWin32HandleInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkWin32KeyedMutexAcquireReleaseInfoNV const &lhs,
                  VkWin32KeyedMutexAcquireReleaseInfoNV const &rhs) noexcept {
    if(lhs.acquireCount != rhs.acquireCount)
      return false;
  
    if(lhs.acquireCount != rhs.acquireCount)
      return false;
  
    if(lhs.acquireCount != rhs.acquireCount)
      return false;
  
    if(lhs.releaseCount != rhs.releaseCount)
      return false;
  
    if(lhs.releaseCount != rhs.releaseCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.acquireCount; ++i) {
      if(lhs.pAcquireSyncs[i] != rhs.pAcquireSyncs[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.acquireCount; ++i) {
      if(lhs.pAcquireKeys[i] != rhs.pAcquireKeys[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.acquireCount; ++i) {
      if(lhs.pAcquireTimeoutMilliseconds[i] != rhs.pAcquireTimeoutMilliseconds[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.releaseCount; ++i) {
      if(lhs.pReleaseSyncs[i] != rhs.pReleaseSyncs[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.releaseCount; ++i) {
      if(lhs.pReleaseKeys[i] != rhs.pReleaseKeys[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkWin32KeyedMutexAcquireReleaseInfoNV const &lhs,
                  VkWin32KeyedMutexAcquireReleaseInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkDeviceGeneratedCommandsFeaturesNVX const &lhs,
                  VkDeviceGeneratedCommandsFeaturesNVX const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.computeBindingPointSupport == rhs.computeBindingPointSupport);
  }
  
  bool operator!=(VkDeviceGeneratedCommandsFeaturesNVX const &lhs,
                  VkDeviceGeneratedCommandsFeaturesNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGeneratedCommandsLimitsNVX const &lhs,
                  VkDeviceGeneratedCommandsLimitsNVX const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxIndirectCommandsLayoutTokenCount == rhs.maxIndirectCommandsLayoutTokenCount) &&
           (lhs.maxObjectEntryCounts == rhs.maxObjectEntryCounts) &&
           (lhs.minSequenceCountBufferOffsetAlignment == rhs.minSequenceCountBufferOffsetAlignment) &&
           (lhs.minSequenceIndexBufferOffsetAlignment == rhs.minSequenceIndexBufferOffsetAlignment) &&
           (lhs.minCommandsTokenBufferOffsetAlignment == rhs.minCommandsTokenBufferOffsetAlignment);
  }
  
  bool operator!=(VkDeviceGeneratedCommandsLimitsNVX const &lhs,
                  VkDeviceGeneratedCommandsLimitsNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkIndirectCommandsTokenNVX const &lhs,
                  VkIndirectCommandsTokenNVX const &rhs) noexcept {
    return (lhs.tokenType == rhs.tokenType) &&
           (lhs.buffer == rhs.buffer) &&
           (lhs.offset == rhs.offset);
  }
  
  bool operator!=(VkIndirectCommandsTokenNVX const &lhs,
                  VkIndirectCommandsTokenNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkIndirectCommandsLayoutTokenNVX const &lhs,
                  VkIndirectCommandsLayoutTokenNVX const &rhs) noexcept {
    return (lhs.tokenType == rhs.tokenType) &&
           (lhs.bindingUnit == rhs.bindingUnit) &&
           (lhs.dynamicCount == rhs.dynamicCount) &&
           (lhs.divisor == rhs.divisor);
  }
  
  bool operator!=(VkIndirectCommandsLayoutTokenNVX const &lhs,
                  VkIndirectCommandsLayoutTokenNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkIndirectCommandsLayoutCreateInfoNVX const &lhs,
                  VkIndirectCommandsLayoutCreateInfoNVX const &rhs) noexcept {
    if(lhs.tokenCount != rhs.tokenCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.tokenCount; ++i) {
      if(lhs.pTokens[i] != rhs.pTokens[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.pipelineBindPoint == rhs.pipelineBindPoint) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkIndirectCommandsLayoutCreateInfoNVX const &lhs,
                  VkIndirectCommandsLayoutCreateInfoNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCmdProcessCommandsInfoNVX const &lhs,
                  VkCmdProcessCommandsInfoNVX const &rhs) noexcept {
    if(lhs.indirectCommandsTokenCount != rhs.indirectCommandsTokenCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.indirectCommandsTokenCount; ++i) {
      if(lhs.pIndirectCommandsTokens[i] != rhs.pIndirectCommandsTokens[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.objectTable == rhs.objectTable) &&
           (lhs.indirectCommandsLayout == rhs.indirectCommandsLayout) &&
           (lhs.maxSequencesCount == rhs.maxSequencesCount) &&
           (lhs.targetCommandBuffer == rhs.targetCommandBuffer) &&
           (lhs.sequencesCountBuffer == rhs.sequencesCountBuffer) &&
           (lhs.sequencesCountOffset == rhs.sequencesCountOffset) &&
           (lhs.sequencesIndexBuffer == rhs.sequencesIndexBuffer) &&
           (lhs.sequencesIndexOffset == rhs.sequencesIndexOffset);
  }
  
  bool operator!=(VkCmdProcessCommandsInfoNVX const &lhs,
                  VkCmdProcessCommandsInfoNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCmdReserveSpaceForCommandsInfoNVX const &lhs,
                  VkCmdReserveSpaceForCommandsInfoNVX const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.objectTable == rhs.objectTable) &&
           (lhs.indirectCommandsLayout == rhs.indirectCommandsLayout) &&
           (lhs.maxSequencesCount == rhs.maxSequencesCount);
  }
  
  bool operator!=(VkCmdReserveSpaceForCommandsInfoNVX const &lhs,
                  VkCmdReserveSpaceForCommandsInfoNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkObjectTableCreateInfoNVX const &lhs,
                  VkObjectTableCreateInfoNVX const &rhs) noexcept {
    if(lhs.objectCount != rhs.objectCount)
      return false;
  
    if(lhs.objectCount != rhs.objectCount)
      return false;
  
    if(lhs.objectCount != rhs.objectCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.objectCount; ++i) {
      if(lhs.pObjectEntryTypes[i] != rhs.pObjectEntryTypes[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.objectCount; ++i) {
      if(lhs.pObjectEntryCounts[i] != rhs.pObjectEntryCounts[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.objectCount; ++i) {
      if(lhs.pObjectEntryUsageFlags[i] != rhs.pObjectEntryUsageFlags[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.maxUniformBuffersPerDescriptor == rhs.maxUniformBuffersPerDescriptor) &&
           (lhs.maxStorageBuffersPerDescriptor == rhs.maxStorageBuffersPerDescriptor) &&
           (lhs.maxStorageImagesPerDescriptor == rhs.maxStorageImagesPerDescriptor) &&
           (lhs.maxSampledImagesPerDescriptor == rhs.maxSampledImagesPerDescriptor) &&
           (lhs.maxPipelineLayouts == rhs.maxPipelineLayouts);
  }
  
  bool operator!=(VkObjectTableCreateInfoNVX const &lhs,
                  VkObjectTableCreateInfoNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkObjectTableEntryNVX const &lhs,
                  VkObjectTableEntryNVX const &rhs) noexcept {
    return (lhs.type == rhs.type) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkObjectTableEntryNVX const &lhs,
                  VkObjectTableEntryNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkObjectTablePipelineEntryNVX const &lhs,
                  VkObjectTablePipelineEntryNVX const &rhs) noexcept {
    return (lhs.type == rhs.type) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pipeline == rhs.pipeline);
  }
  
  bool operator!=(VkObjectTablePipelineEntryNVX const &lhs,
                  VkObjectTablePipelineEntryNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkObjectTableDescriptorSetEntryNVX const &lhs,
                  VkObjectTableDescriptorSetEntryNVX const &rhs) noexcept {
    return (lhs.type == rhs.type) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pipelineLayout == rhs.pipelineLayout) &&
           (lhs.descriptorSet == rhs.descriptorSet);
  }
  
  bool operator!=(VkObjectTableDescriptorSetEntryNVX const &lhs,
                  VkObjectTableDescriptorSetEntryNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkObjectTableVertexBufferEntryNVX const &lhs,
                  VkObjectTableVertexBufferEntryNVX const &rhs) noexcept {
    return (lhs.type == rhs.type) &&
           (lhs.flags == rhs.flags) &&
           (lhs.buffer == rhs.buffer);
  }
  
  bool operator!=(VkObjectTableVertexBufferEntryNVX const &lhs,
                  VkObjectTableVertexBufferEntryNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkObjectTableIndexBufferEntryNVX const &lhs,
                  VkObjectTableIndexBufferEntryNVX const &rhs) noexcept {
    return (lhs.type == rhs.type) &&
           (lhs.flags == rhs.flags) &&
           (lhs.buffer == rhs.buffer) &&
           (lhs.indexType == rhs.indexType);
  }
  
  bool operator!=(VkObjectTableIndexBufferEntryNVX const &lhs,
                  VkObjectTableIndexBufferEntryNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkObjectTablePushConstantEntryNVX const &lhs,
                  VkObjectTablePushConstantEntryNVX const &rhs) noexcept {
    return (lhs.type == rhs.type) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pipelineLayout == rhs.pipelineLayout) &&
           (lhs.stageFlags == rhs.stageFlags);
  }
  
  bool operator!=(VkObjectTablePushConstantEntryNVX const &lhs,
                  VkObjectTablePushConstantEntryNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceFeatures2 const &lhs,
                  VkPhysicalDeviceFeatures2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.features == rhs.features);
  }
  
  bool operator!=(VkPhysicalDeviceFeatures2 const &lhs,
                  VkPhysicalDeviceFeatures2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceProperties2 const &lhs,
                  VkPhysicalDeviceProperties2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.properties == rhs.properties);
  }
  
  bool operator!=(VkPhysicalDeviceProperties2 const &lhs,
                  VkPhysicalDeviceProperties2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkFormatProperties2 const &lhs,
                  VkFormatProperties2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.formatProperties == rhs.formatProperties);
  }
  
  bool operator!=(VkFormatProperties2 const &lhs,
                  VkFormatProperties2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageFormatProperties2 const &lhs,
                  VkImageFormatProperties2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.imageFormatProperties == rhs.imageFormatProperties);
  }
  
  bool operator!=(VkImageFormatProperties2 const &lhs,
                  VkImageFormatProperties2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceImageFormatInfo2 const &lhs,
                  VkPhysicalDeviceImageFormatInfo2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.format == rhs.format) &&
           (lhs.type == rhs.type) &&
           (lhs.tiling == rhs.tiling) &&
           (lhs.usage == rhs.usage) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkPhysicalDeviceImageFormatInfo2 const &lhs,
                  VkPhysicalDeviceImageFormatInfo2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkQueueFamilyProperties2 const &lhs,
                  VkQueueFamilyProperties2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.queueFamilyProperties == rhs.queueFamilyProperties);
  }
  
  bool operator!=(VkQueueFamilyProperties2 const &lhs,
                  VkQueueFamilyProperties2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceMemoryProperties2 const &lhs,
                  VkPhysicalDeviceMemoryProperties2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memoryProperties == rhs.memoryProperties);
  }
  
  bool operator!=(VkPhysicalDeviceMemoryProperties2 const &lhs,
                  VkPhysicalDeviceMemoryProperties2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseImageFormatProperties2 const &lhs,
                  VkSparseImageFormatProperties2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.properties == rhs.properties);
  }
  
  bool operator!=(VkSparseImageFormatProperties2 const &lhs,
                  VkSparseImageFormatProperties2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceSparseImageFormatInfo2 const &lhs,
                  VkPhysicalDeviceSparseImageFormatInfo2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.format == rhs.format) &&
           (lhs.type == rhs.type) &&
           (lhs.samples == rhs.samples) &&
           (lhs.usage == rhs.usage) &&
           (lhs.tiling == rhs.tiling);
  }
  
  bool operator!=(VkPhysicalDeviceSparseImageFormatInfo2 const &lhs,
                  VkPhysicalDeviceSparseImageFormatInfo2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDevicePushDescriptorPropertiesKHR const &lhs,
                  VkPhysicalDevicePushDescriptorPropertiesKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxPushDescriptors == rhs.maxPushDescriptors);
  }
  
  bool operator!=(VkPhysicalDevicePushDescriptorPropertiesKHR const &lhs,
                  VkPhysicalDevicePushDescriptorPropertiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkConformanceVersionKHR const &lhs,
                  VkConformanceVersionKHR const &rhs) noexcept {
    return (lhs.major == rhs.major) &&
           (lhs.minor == rhs.minor) &&
           (lhs.subminor == rhs.subminor) &&
           (lhs.patch == rhs.patch);
  }
  
  bool operator!=(VkConformanceVersionKHR const &lhs,
                  VkConformanceVersionKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceDriverPropertiesKHR const &lhs,
                  VkPhysicalDeviceDriverPropertiesKHR const &rhs) noexcept {
    for(uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
      if(lhs.driverName[i] != rhs.driverName[i])
        return false;
    }
  
    for(uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
      if(lhs.driverInfo[i] != rhs.driverInfo[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.driverID == rhs.driverID) &&
           (lhs.conformanceVersion == rhs.conformanceVersion);
  }
  
  bool operator!=(VkPhysicalDeviceDriverPropertiesKHR const &lhs,
                  VkPhysicalDeviceDriverPropertiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPresentRegionsKHR const &lhs,
                  VkPresentRegionsKHR const &rhs) noexcept {
    if(lhs.swapchainCount != rhs.swapchainCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.swapchainCount; ++i) {
      if(lhs.pRegions[i] != rhs.pRegions[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkPresentRegionsKHR const &lhs,
                  VkPresentRegionsKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPresentRegionKHR const &lhs,
                  VkPresentRegionKHR const &rhs) noexcept {
    if(lhs.rectangleCount != rhs.rectangleCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.rectangleCount; ++i) {
      if(lhs.pRectangles[i] != rhs.pRectangles[i])
        return false;
    }
  
    return true;
  }
  
  bool operator!=(VkPresentRegionKHR const &lhs,
                  VkPresentRegionKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRectLayerKHR const &lhs,
                  VkRectLayerKHR const &rhs) noexcept {
    return (lhs.offset == rhs.offset) &&
           (lhs.extent == rhs.extent) &&
           (lhs.layer == rhs.layer);
  }
  
  bool operator!=(VkRectLayerKHR const &lhs,
                  VkRectLayerKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceVariablePointerFeatures const &lhs,
                  VkPhysicalDeviceVariablePointerFeatures const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.variablePointersStorageBuffer == rhs.variablePointersStorageBuffer) &&
           (lhs.variablePointers == rhs.variablePointers);
  }
  
  bool operator!=(VkPhysicalDeviceVariablePointerFeatures const &lhs,
                  VkPhysicalDeviceVariablePointerFeatures const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalMemoryProperties const &lhs,
                  VkExternalMemoryProperties const &rhs) noexcept {
    return (lhs.externalMemoryFeatures == rhs.externalMemoryFeatures) &&
           (lhs.exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes) &&
           (lhs.compatibleHandleTypes == rhs.compatibleHandleTypes);
  }
  
  bool operator!=(VkExternalMemoryProperties const &lhs,
                  VkExternalMemoryProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceExternalImageFormatInfo const &lhs,
                  VkPhysicalDeviceExternalImageFormatInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkPhysicalDeviceExternalImageFormatInfo const &lhs,
                  VkPhysicalDeviceExternalImageFormatInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalImageFormatProperties const &lhs,
                  VkExternalImageFormatProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.externalMemoryProperties == rhs.externalMemoryProperties);
  }
  
  bool operator!=(VkExternalImageFormatProperties const &lhs,
                  VkExternalImageFormatProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceExternalBufferInfo const &lhs,
                  VkPhysicalDeviceExternalBufferInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.usage == rhs.usage) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkPhysicalDeviceExternalBufferInfo const &lhs,
                  VkPhysicalDeviceExternalBufferInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalBufferProperties const &lhs,
                  VkExternalBufferProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.externalMemoryProperties == rhs.externalMemoryProperties);
  }
  
  bool operator!=(VkExternalBufferProperties const &lhs,
                  VkExternalBufferProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceIDProperties const &lhs,
                  VkPhysicalDeviceIDProperties const &rhs) noexcept {
    for(uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
      if(lhs.deviceUUID[i] != rhs.deviceUUID[i])
        return false;
    }
  
    for(uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
      if(lhs.driverUUID[i] != rhs.driverUUID[i])
        return false;
    }
  
    for(uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
      if(lhs.deviceLUID[i] != rhs.deviceLUID[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.deviceNodeMask == rhs.deviceNodeMask) &&
           (lhs.deviceLUIDValid == rhs.deviceLUIDValid);
  }
  
  bool operator!=(VkPhysicalDeviceIDProperties const &lhs,
                  VkPhysicalDeviceIDProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalMemoryImageCreateInfo const &lhs,
                  VkExternalMemoryImageCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleTypes == rhs.handleTypes);
  }
  
  bool operator!=(VkExternalMemoryImageCreateInfo const &lhs,
                  VkExternalMemoryImageCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalMemoryBufferCreateInfo const &lhs,
                  VkExternalMemoryBufferCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleTypes == rhs.handleTypes);
  }
  
  bool operator!=(VkExternalMemoryBufferCreateInfo const &lhs,
                  VkExternalMemoryBufferCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExportMemoryAllocateInfo const &lhs,
                  VkExportMemoryAllocateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleTypes == rhs.handleTypes);
  }
  
  bool operator!=(VkExportMemoryAllocateInfo const &lhs,
                  VkExportMemoryAllocateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkImportMemoryWin32HandleInfoKHR const &lhs,
                  VkImportMemoryWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleType == rhs.handleType) &&
           (lhs.handle == rhs.handle) &&
           (lhs.name == rhs.name);
  }
  
  bool operator!=(VkImportMemoryWin32HandleInfoKHR const &lhs,
                  VkImportMemoryWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkExportMemoryWin32HandleInfoKHR const &lhs,
                  VkExportMemoryWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.pAttributes == rhs.pAttributes) &&
           (lhs.dwAccess == rhs.dwAccess) &&
           (lhs.name == rhs.name);
  }
  
  bool operator!=(VkExportMemoryWin32HandleInfoKHR const &lhs,
                  VkExportMemoryWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkMemoryWin32HandlePropertiesKHR const &lhs,
                  VkMemoryWin32HandlePropertiesKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memoryTypeBits == rhs.memoryTypeBits);
  }
  
  bool operator!=(VkMemoryWin32HandlePropertiesKHR const &lhs,
                  VkMemoryWin32HandlePropertiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkMemoryGetWin32HandleInfoKHR const &lhs,
                  VkMemoryGetWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memory == rhs.memory) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkMemoryGetWin32HandleInfoKHR const &lhs,
                  VkMemoryGetWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkImportMemoryFdInfoKHR const &lhs,
                  VkImportMemoryFdInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleType == rhs.handleType) &&
           (lhs.fd == rhs.fd);
  }
  
  bool operator!=(VkImportMemoryFdInfoKHR const &lhs,
                  VkImportMemoryFdInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryFdPropertiesKHR const &lhs,
                  VkMemoryFdPropertiesKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memoryTypeBits == rhs.memoryTypeBits);
  }
  
  bool operator!=(VkMemoryFdPropertiesKHR const &lhs,
                  VkMemoryFdPropertiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryGetFdInfoKHR const &lhs,
                  VkMemoryGetFdInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memory == rhs.memory) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkMemoryGetFdInfoKHR const &lhs,
                  VkMemoryGetFdInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkWin32KeyedMutexAcquireReleaseInfoKHR const &lhs,
                  VkWin32KeyedMutexAcquireReleaseInfoKHR const &rhs) noexcept {
    if(lhs.acquireCount != rhs.acquireCount)
      return false;
  
    if(lhs.acquireCount != rhs.acquireCount)
      return false;
  
    if(lhs.acquireCount != rhs.acquireCount)
      return false;
  
    if(lhs.releaseCount != rhs.releaseCount)
      return false;
  
    if(lhs.releaseCount != rhs.releaseCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.acquireCount; ++i) {
      if(lhs.pAcquireSyncs[i] != rhs.pAcquireSyncs[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.acquireCount; ++i) {
      if(lhs.pAcquireKeys[i] != rhs.pAcquireKeys[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.acquireCount; ++i) {
      if(lhs.pAcquireTimeouts[i] != rhs.pAcquireTimeouts[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.releaseCount; ++i) {
      if(lhs.pReleaseSyncs[i] != rhs.pReleaseSyncs[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.releaseCount; ++i) {
      if(lhs.pReleaseKeys[i] != rhs.pReleaseKeys[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkWin32KeyedMutexAcquireReleaseInfoKHR const &lhs,
                  VkWin32KeyedMutexAcquireReleaseInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkPhysicalDeviceExternalSemaphoreInfo const &lhs,
                  VkPhysicalDeviceExternalSemaphoreInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkPhysicalDeviceExternalSemaphoreInfo const &lhs,
                  VkPhysicalDeviceExternalSemaphoreInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalSemaphoreProperties const &lhs,
                  VkExternalSemaphoreProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes) &&
           (lhs.compatibleHandleTypes == rhs.compatibleHandleTypes) &&
           (lhs.externalSemaphoreFeatures == rhs.externalSemaphoreFeatures);
  }
  
  bool operator!=(VkExternalSemaphoreProperties const &lhs,
                  VkExternalSemaphoreProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExportSemaphoreCreateInfo const &lhs,
                  VkExportSemaphoreCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleTypes == rhs.handleTypes);
  }
  
  bool operator!=(VkExportSemaphoreCreateInfo const &lhs,
                  VkExportSemaphoreCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkImportSemaphoreWin32HandleInfoKHR const &lhs,
                  VkImportSemaphoreWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.semaphore == rhs.semaphore) &&
           (lhs.flags == rhs.flags) &&
           (lhs.handleType == rhs.handleType) &&
           (lhs.handle == rhs.handle) &&
           (lhs.name == rhs.name);
  }
  
  bool operator!=(VkImportSemaphoreWin32HandleInfoKHR const &lhs,
                  VkImportSemaphoreWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkExportSemaphoreWin32HandleInfoKHR const &lhs,
                  VkExportSemaphoreWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.pAttributes == rhs.pAttributes) &&
           (lhs.dwAccess == rhs.dwAccess) &&
           (lhs.name == rhs.name);
  }
  
  bool operator!=(VkExportSemaphoreWin32HandleInfoKHR const &lhs,
                  VkExportSemaphoreWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkD3D12FenceSubmitInfoKHR const &lhs,
                  VkD3D12FenceSubmitInfoKHR const &rhs) noexcept {
    if(lhs.waitSemaphoreValuesCount != rhs.waitSemaphoreValuesCount)
      return false;
  
    if(lhs.signalSemaphoreValuesCount != rhs.signalSemaphoreValuesCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.waitSemaphoreValuesCount; ++i) {
      if(lhs.pWaitSemaphoreValues[i] != rhs.pWaitSemaphoreValues[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.signalSemaphoreValuesCount; ++i) {
      if(lhs.pSignalSemaphoreValues[i] != rhs.pSignalSemaphoreValues[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkD3D12FenceSubmitInfoKHR const &lhs,
                  VkD3D12FenceSubmitInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkSemaphoreGetWin32HandleInfoKHR const &lhs,
                  VkSemaphoreGetWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.semaphore == rhs.semaphore) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkSemaphoreGetWin32HandleInfoKHR const &lhs,
                  VkSemaphoreGetWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkImportSemaphoreFdInfoKHR const &lhs,
                  VkImportSemaphoreFdInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.semaphore == rhs.semaphore) &&
           (lhs.flags == rhs.flags) &&
           (lhs.handleType == rhs.handleType) &&
           (lhs.fd == rhs.fd);
  }
  
  bool operator!=(VkImportSemaphoreFdInfoKHR const &lhs,
                  VkImportSemaphoreFdInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSemaphoreGetFdInfoKHR const &lhs,
                  VkSemaphoreGetFdInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.semaphore == rhs.semaphore) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkSemaphoreGetFdInfoKHR const &lhs,
                  VkSemaphoreGetFdInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceExternalFenceInfo const &lhs,
                  VkPhysicalDeviceExternalFenceInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkPhysicalDeviceExternalFenceInfo const &lhs,
                  VkPhysicalDeviceExternalFenceInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExternalFenceProperties const &lhs,
                  VkExternalFenceProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes) &&
           (lhs.compatibleHandleTypes == rhs.compatibleHandleTypes) &&
           (lhs.externalFenceFeatures == rhs.externalFenceFeatures);
  }
  
  bool operator!=(VkExternalFenceProperties const &lhs,
                  VkExternalFenceProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkExportFenceCreateInfo const &lhs,
                  VkExportFenceCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleTypes == rhs.handleTypes);
  }
  
  bool operator!=(VkExportFenceCreateInfo const &lhs,
                  VkExportFenceCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkImportFenceWin32HandleInfoKHR const &lhs,
                  VkImportFenceWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.fence == rhs.fence) &&
           (lhs.flags == rhs.flags) &&
           (lhs.handleType == rhs.handleType) &&
           (lhs.handle == rhs.handle) &&
           (lhs.name == rhs.name);
  }
  
  bool operator!=(VkImportFenceWin32HandleInfoKHR const &lhs,
                  VkImportFenceWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkExportFenceWin32HandleInfoKHR const &lhs,
                  VkExportFenceWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.pAttributes == rhs.pAttributes) &&
           (lhs.dwAccess == rhs.dwAccess) &&
           (lhs.name == rhs.name);
  }
  
  bool operator!=(VkExportFenceWin32HandleInfoKHR const &lhs,
                  VkExportFenceWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  bool operator==(VkFenceGetWin32HandleInfoKHR const &lhs,
                  VkFenceGetWin32HandleInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.fence == rhs.fence) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkFenceGetWin32HandleInfoKHR const &lhs,
                  VkFenceGetWin32HandleInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  bool operator==(VkImportFenceFdInfoKHR const &lhs,
                  VkImportFenceFdInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.fence == rhs.fence) &&
           (lhs.flags == rhs.flags) &&
           (lhs.handleType == rhs.handleType) &&
           (lhs.fd == rhs.fd);
  }
  
  bool operator!=(VkImportFenceFdInfoKHR const &lhs,
                  VkImportFenceFdInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkFenceGetFdInfoKHR const &lhs,
                  VkFenceGetFdInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.fence == rhs.fence) &&
           (lhs.handleType == rhs.handleType);
  }
  
  bool operator!=(VkFenceGetFdInfoKHR const &lhs,
                  VkFenceGetFdInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceMultiviewFeatures const &lhs,
                  VkPhysicalDeviceMultiviewFeatures const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.multiview == rhs.multiview) &&
           (lhs.multiviewGeometryShader == rhs.multiviewGeometryShader) &&
           (lhs.multiviewTessellationShader == rhs.multiviewTessellationShader);
  }
  
  bool operator!=(VkPhysicalDeviceMultiviewFeatures const &lhs,
                  VkPhysicalDeviceMultiviewFeatures const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceMultiviewProperties const &lhs,
                  VkPhysicalDeviceMultiviewProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxMultiviewViewCount == rhs.maxMultiviewViewCount) &&
           (lhs.maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex);
  }
  
  bool operator!=(VkPhysicalDeviceMultiviewProperties const &lhs,
                  VkPhysicalDeviceMultiviewProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRenderPassMultiviewCreateInfo const &lhs,
                  VkRenderPassMultiviewCreateInfo const &rhs) noexcept {
    if(lhs.subpassCount != rhs.subpassCount)
      return false;
  
    if(lhs.dependencyCount != rhs.dependencyCount)
      return false;
  
    if(lhs.correlationMaskCount != rhs.correlationMaskCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.subpassCount; ++i) {
      if(lhs.pViewMasks[i] != rhs.pViewMasks[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.dependencyCount; ++i) {
      if(lhs.pViewOffsets[i] != rhs.pViewOffsets[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.correlationMaskCount; ++i) {
      if(lhs.pCorrelationMasks[i] != rhs.pCorrelationMasks[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkRenderPassMultiviewCreateInfo const &lhs,
                  VkRenderPassMultiviewCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSurfaceCapabilities2EXT const &lhs,
                  VkSurfaceCapabilities2EXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.minImageCount == rhs.minImageCount) &&
           (lhs.maxImageCount == rhs.maxImageCount) &&
           (lhs.currentExtent == rhs.currentExtent) &&
           (lhs.minImageExtent == rhs.minImageExtent) &&
           (lhs.maxImageExtent == rhs.maxImageExtent) &&
           (lhs.maxImageArrayLayers == rhs.maxImageArrayLayers) &&
           (lhs.supportedTransforms == rhs.supportedTransforms) &&
           (lhs.currentTransform == rhs.currentTransform) &&
           (lhs.supportedCompositeAlpha == rhs.supportedCompositeAlpha) &&
           (lhs.supportedUsageFlags == rhs.supportedUsageFlags) &&
           (lhs.supportedSurfaceCounters == rhs.supportedSurfaceCounters);
  }
  
  bool operator!=(VkSurfaceCapabilities2EXT const &lhs,
                  VkSurfaceCapabilities2EXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayPowerInfoEXT const &lhs,
                  VkDisplayPowerInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.powerState == rhs.powerState);
  }
  
  bool operator!=(VkDisplayPowerInfoEXT const &lhs,
                  VkDisplayPowerInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceEventInfoEXT const &lhs,
                  VkDeviceEventInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.deviceEvent == rhs.deviceEvent);
  }
  
  bool operator!=(VkDeviceEventInfoEXT const &lhs,
                  VkDeviceEventInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayEventInfoEXT const &lhs,
                  VkDisplayEventInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.displayEvent == rhs.displayEvent);
  }
  
  bool operator!=(VkDisplayEventInfoEXT const &lhs,
                  VkDisplayEventInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSwapchainCounterCreateInfoEXT const &lhs,
                  VkSwapchainCounterCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.surfaceCounters == rhs.surfaceCounters);
  }
  
  bool operator!=(VkSwapchainCounterCreateInfoEXT const &lhs,
                  VkSwapchainCounterCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceGroupProperties const &lhs,
                  VkPhysicalDeviceGroupProperties const &rhs) noexcept {
    for(uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
      if(lhs.physicalDevices[i] != rhs.physicalDevices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.physicalDeviceCount == rhs.physicalDeviceCount) &&
           (lhs.subsetAllocation == rhs.subsetAllocation);
  }
  
  bool operator!=(VkPhysicalDeviceGroupProperties const &lhs,
                  VkPhysicalDeviceGroupProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryAllocateFlagsInfo const &lhs,
                  VkMemoryAllocateFlagsInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.deviceMask == rhs.deviceMask);
  }
  
  bool operator!=(VkMemoryAllocateFlagsInfo const &lhs,
                  VkMemoryAllocateFlagsInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBindBufferMemoryInfo const &lhs,
                  VkBindBufferMemoryInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.buffer == rhs.buffer) &&
           (lhs.memory == rhs.memory) &&
           (lhs.memoryOffset == rhs.memoryOffset);
  }
  
  bool operator!=(VkBindBufferMemoryInfo const &lhs,
                  VkBindBufferMemoryInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBindBufferMemoryDeviceGroupInfo const &lhs,
                  VkBindBufferMemoryDeviceGroupInfo const &rhs) noexcept {
    if(lhs.deviceIndexCount != rhs.deviceIndexCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.deviceIndexCount; ++i) {
      if(lhs.pDeviceIndices[i] != rhs.pDeviceIndices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkBindBufferMemoryDeviceGroupInfo const &lhs,
                  VkBindBufferMemoryDeviceGroupInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBindImageMemoryInfo const &lhs,
                  VkBindImageMemoryInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.image == rhs.image) &&
           (lhs.memory == rhs.memory) &&
           (lhs.memoryOffset == rhs.memoryOffset);
  }
  
  bool operator!=(VkBindImageMemoryInfo const &lhs,
                  VkBindImageMemoryInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBindImageMemoryDeviceGroupInfo const &lhs,
                  VkBindImageMemoryDeviceGroupInfo const &rhs) noexcept {
    if(lhs.deviceIndexCount != rhs.deviceIndexCount)
      return false;
  
    if(lhs.splitInstanceBindRegionCount != rhs.splitInstanceBindRegionCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.deviceIndexCount; ++i) {
      if(lhs.pDeviceIndices[i] != rhs.pDeviceIndices[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.splitInstanceBindRegionCount; ++i) {
      if(lhs.pSplitInstanceBindRegions[i] != rhs.pSplitInstanceBindRegions[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkBindImageMemoryDeviceGroupInfo const &lhs,
                  VkBindImageMemoryDeviceGroupInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGroupRenderPassBeginInfo const &lhs,
                  VkDeviceGroupRenderPassBeginInfo const &rhs) noexcept {
    if(lhs.deviceRenderAreaCount != rhs.deviceRenderAreaCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.deviceRenderAreaCount; ++i) {
      if(lhs.pDeviceRenderAreas[i] != rhs.pDeviceRenderAreas[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.deviceMask == rhs.deviceMask);
  }
  
  bool operator!=(VkDeviceGroupRenderPassBeginInfo const &lhs,
                  VkDeviceGroupRenderPassBeginInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGroupCommandBufferBeginInfo const &lhs,
                  VkDeviceGroupCommandBufferBeginInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.deviceMask == rhs.deviceMask);
  }
  
  bool operator!=(VkDeviceGroupCommandBufferBeginInfo const &lhs,
                  VkDeviceGroupCommandBufferBeginInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGroupSubmitInfo const &lhs,
                  VkDeviceGroupSubmitInfo const &rhs) noexcept {
    if(lhs.waitSemaphoreCount != rhs.waitSemaphoreCount)
      return false;
  
    if(lhs.commandBufferCount != rhs.commandBufferCount)
      return false;
  
    if(lhs.signalSemaphoreCount != rhs.signalSemaphoreCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.waitSemaphoreCount; ++i) {
      if(lhs.pWaitSemaphoreDeviceIndices[i] != rhs.pWaitSemaphoreDeviceIndices[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.commandBufferCount; ++i) {
      if(lhs.pCommandBufferDeviceMasks[i] != rhs.pCommandBufferDeviceMasks[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.signalSemaphoreCount; ++i) {
      if(lhs.pSignalSemaphoreDeviceIndices[i] != rhs.pSignalSemaphoreDeviceIndices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkDeviceGroupSubmitInfo const &lhs,
                  VkDeviceGroupSubmitInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGroupBindSparseInfo const &lhs,
                  VkDeviceGroupBindSparseInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.resourceDeviceIndex == rhs.resourceDeviceIndex) &&
           (lhs.memoryDeviceIndex == rhs.memoryDeviceIndex);
  }
  
  bool operator!=(VkDeviceGroupBindSparseInfo const &lhs,
                  VkDeviceGroupBindSparseInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGroupPresentCapabilitiesKHR const &lhs,
                  VkDeviceGroupPresentCapabilitiesKHR const &rhs) noexcept {
    for(uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
      if(lhs.presentMask[i] != rhs.presentMask[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.modes == rhs.modes);
  }
  
  bool operator!=(VkDeviceGroupPresentCapabilitiesKHR const &lhs,
                  VkDeviceGroupPresentCapabilitiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageSwapchainCreateInfoKHR const &lhs,
                  VkImageSwapchainCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.swapchain == rhs.swapchain);
  }
  
  bool operator!=(VkImageSwapchainCreateInfoKHR const &lhs,
                  VkImageSwapchainCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBindImageMemorySwapchainInfoKHR const &lhs,
                  VkBindImageMemorySwapchainInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.swapchain == rhs.swapchain) &&
           (lhs.imageIndex == rhs.imageIndex);
  }
  
  bool operator!=(VkBindImageMemorySwapchainInfoKHR const &lhs,
                  VkBindImageMemorySwapchainInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAcquireNextImageInfoKHR const &lhs,
                  VkAcquireNextImageInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.swapchain == rhs.swapchain) &&
           (lhs.timeout == rhs.timeout) &&
           (lhs.semaphore == rhs.semaphore) &&
           (lhs.fence == rhs.fence) &&
           (lhs.deviceMask == rhs.deviceMask);
  }
  
  bool operator!=(VkAcquireNextImageInfoKHR const &lhs,
                  VkAcquireNextImageInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGroupPresentInfoKHR const &lhs,
                  VkDeviceGroupPresentInfoKHR const &rhs) noexcept {
    if(lhs.swapchainCount != rhs.swapchainCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.swapchainCount; ++i) {
      if(lhs.pDeviceMasks[i] != rhs.pDeviceMasks[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.mode == rhs.mode);
  }
  
  bool operator!=(VkDeviceGroupPresentInfoKHR const &lhs,
                  VkDeviceGroupPresentInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGroupDeviceCreateInfo const &lhs,
                  VkDeviceGroupDeviceCreateInfo const &rhs) noexcept {
    if(lhs.physicalDeviceCount != rhs.physicalDeviceCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.physicalDeviceCount; ++i) {
      if(lhs.pPhysicalDevices[i] != rhs.pPhysicalDevices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkDeviceGroupDeviceCreateInfo const &lhs,
                  VkDeviceGroupDeviceCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceGroupSwapchainCreateInfoKHR const &lhs,
                  VkDeviceGroupSwapchainCreateInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.modes == rhs.modes);
  }
  
  bool operator!=(VkDeviceGroupSwapchainCreateInfoKHR const &lhs,
                  VkDeviceGroupSwapchainCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorUpdateTemplateEntry const &lhs,
                  VkDescriptorUpdateTemplateEntry const &rhs) noexcept {
    return (lhs.dstBinding == rhs.dstBinding) &&
           (lhs.dstArrayElement == rhs.dstArrayElement) &&
           (lhs.descriptorCount == rhs.descriptorCount) &&
           (lhs.descriptorType == rhs.descriptorType) &&
           (lhs.offset == rhs.offset) &&
           (lhs.stride == rhs.stride);
  }
  
  bool operator!=(VkDescriptorUpdateTemplateEntry const &lhs,
                  VkDescriptorUpdateTemplateEntry const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorUpdateTemplateCreateInfo const &lhs,
                  VkDescriptorUpdateTemplateCreateInfo const &rhs) noexcept {
    if(lhs.descriptorUpdateEntryCount != rhs.descriptorUpdateEntryCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.descriptorUpdateEntryCount; ++i) {
      if(lhs.pDescriptorUpdateEntries[i] != rhs.pDescriptorUpdateEntries[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.templateType == rhs.templateType) &&
           (lhs.descriptorSetLayout == rhs.descriptorSetLayout) &&
           (lhs.pipelineBindPoint == rhs.pipelineBindPoint) &&
           (lhs.pipelineLayout == rhs.pipelineLayout) &&
           (lhs.set == rhs.set);
  }
  
  bool operator!=(VkDescriptorUpdateTemplateCreateInfo const &lhs,
                  VkDescriptorUpdateTemplateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkXYColorEXT const &lhs,
                  VkXYColorEXT const &rhs) noexcept {
    return (lhs.x == rhs.x) &&
           (lhs.y == rhs.y);
  }
  
  bool operator!=(VkXYColorEXT const &lhs,
                  VkXYColorEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkHdrMetadataEXT const &lhs,
                  VkHdrMetadataEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.displayPrimaryRed == rhs.displayPrimaryRed) &&
           (lhs.displayPrimaryGreen == rhs.displayPrimaryGreen) &&
           (lhs.displayPrimaryBlue == rhs.displayPrimaryBlue) &&
           (lhs.whitePoint == rhs.whitePoint) &&
           (lhs.maxLuminance == rhs.maxLuminance) &&
           (lhs.minLuminance == rhs.minLuminance) &&
           (lhs.maxContentLightLevel == rhs.maxContentLightLevel) &&
           (lhs.maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel);
  }
  
  bool operator!=(VkHdrMetadataEXT const &lhs,
                  VkHdrMetadataEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRefreshCycleDurationGOOGLE const &lhs,
                  VkRefreshCycleDurationGOOGLE const &rhs) noexcept {
    return (lhs.refreshDuration == rhs.refreshDuration);
  }
  
  bool operator!=(VkRefreshCycleDurationGOOGLE const &lhs,
                  VkRefreshCycleDurationGOOGLE const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPastPresentationTimingGOOGLE const &lhs,
                  VkPastPresentationTimingGOOGLE const &rhs) noexcept {
    return (lhs.presentID == rhs.presentID) &&
           (lhs.desiredPresentTime == rhs.desiredPresentTime) &&
           (lhs.actualPresentTime == rhs.actualPresentTime) &&
           (lhs.earliestPresentTime == rhs.earliestPresentTime) &&
           (lhs.presentMargin == rhs.presentMargin);
  }
  
  bool operator!=(VkPastPresentationTimingGOOGLE const &lhs,
                  VkPastPresentationTimingGOOGLE const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPresentTimesInfoGOOGLE const &lhs,
                  VkPresentTimesInfoGOOGLE const &rhs) noexcept {
    if(lhs.swapchainCount != rhs.swapchainCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.swapchainCount; ++i) {
      if(lhs.pTimes[i] != rhs.pTimes[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkPresentTimesInfoGOOGLE const &lhs,
                  VkPresentTimesInfoGOOGLE const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPresentTimeGOOGLE const &lhs,
                  VkPresentTimeGOOGLE const &rhs) noexcept {
    return (lhs.presentID == rhs.presentID) &&
           (lhs.desiredPresentTime == rhs.desiredPresentTime);
  }
  
  bool operator!=(VkPresentTimeGOOGLE const &lhs,
                  VkPresentTimeGOOGLE const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_IOS_MVK
  bool operator==(VkIOSSurfaceCreateInfoMVK const &lhs,
                  VkIOSSurfaceCreateInfoMVK const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pView == rhs.pView);
  }
  
  bool operator!=(VkIOSSurfaceCreateInfoMVK const &lhs,
                  VkIOSSurfaceCreateInfoMVK const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_IOS_MVK
  
  #ifdef VK_USE_PLATFORM_MACOS_MVK
  bool operator==(VkMacOSSurfaceCreateInfoMVK const &lhs,
                  VkMacOSSurfaceCreateInfoMVK const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pView == rhs.pView);
  }
  
  bool operator!=(VkMacOSSurfaceCreateInfoMVK const &lhs,
                  VkMacOSSurfaceCreateInfoMVK const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_MACOS_MVK
  
  bool operator==(VkViewportWScalingNV const &lhs,
                  VkViewportWScalingNV const &rhs) noexcept {
    return (lhs.xcoeff == rhs.xcoeff) &&
           (lhs.ycoeff == rhs.ycoeff);
  }
  
  bool operator!=(VkViewportWScalingNV const &lhs,
                  VkViewportWScalingNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineViewportWScalingStateCreateInfoNV const &lhs,
                  VkPipelineViewportWScalingStateCreateInfoNV const &rhs) noexcept {
    if(lhs.viewportCount != rhs.viewportCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.viewportCount; ++i) {
      if(lhs.pViewportWScalings[i] != rhs.pViewportWScalings[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.viewportWScalingEnable == rhs.viewportWScalingEnable);
  }
  
  bool operator!=(VkPipelineViewportWScalingStateCreateInfoNV const &lhs,
                  VkPipelineViewportWScalingStateCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkViewportSwizzleNV const &lhs,
                  VkViewportSwizzleNV const &rhs) noexcept {
    return (lhs.x == rhs.x) &&
           (lhs.y == rhs.y) &&
           (lhs.z == rhs.z) &&
           (lhs.w == rhs.w);
  }
  
  bool operator!=(VkViewportSwizzleNV const &lhs,
                  VkViewportSwizzleNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineViewportSwizzleStateCreateInfoNV const &lhs,
                  VkPipelineViewportSwizzleStateCreateInfoNV const &rhs) noexcept {
    if(lhs.viewportCount != rhs.viewportCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.viewportCount; ++i) {
      if(lhs.pViewportSwizzles[i] != rhs.pViewportSwizzles[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkPipelineViewportSwizzleStateCreateInfoNV const &lhs,
                  VkPipelineViewportSwizzleStateCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceDiscardRectanglePropertiesEXT const &lhs,
                  VkPhysicalDeviceDiscardRectanglePropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxDiscardRectangles == rhs.maxDiscardRectangles);
  }
  
  bool operator!=(VkPhysicalDeviceDiscardRectanglePropertiesEXT const &lhs,
                  VkPhysicalDeviceDiscardRectanglePropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineDiscardRectangleStateCreateInfoEXT const &lhs,
                  VkPipelineDiscardRectangleStateCreateInfoEXT const &rhs) noexcept {
    if(lhs.discardRectangleCount != rhs.discardRectangleCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.discardRectangleCount; ++i) {
      if(lhs.pDiscardRectangles[i] != rhs.pDiscardRectangles[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.discardRectangleMode == rhs.discardRectangleMode);
  }
  
  bool operator!=(VkPipelineDiscardRectangleStateCreateInfoEXT const &lhs,
                  VkPipelineDiscardRectangleStateCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &lhs,
                  VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.perViewPositionAllComponents == rhs.perViewPositionAllComponents);
  }
  
  bool operator!=(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &lhs,
                  VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkInputAttachmentAspectReference const &lhs,
                  VkInputAttachmentAspectReference const &rhs) noexcept {
    return (lhs.subpass == rhs.subpass) &&
           (lhs.inputAttachmentIndex == rhs.inputAttachmentIndex) &&
           (lhs.aspectMask == rhs.aspectMask);
  }
  
  bool operator!=(VkInputAttachmentAspectReference const &lhs,
                  VkInputAttachmentAspectReference const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRenderPassInputAttachmentAspectCreateInfo const &lhs,
                  VkRenderPassInputAttachmentAspectCreateInfo const &rhs) noexcept {
    if(lhs.aspectReferenceCount != rhs.aspectReferenceCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.aspectReferenceCount; ++i) {
      if(lhs.pAspectReferences[i] != rhs.pAspectReferences[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkRenderPassInputAttachmentAspectCreateInfo const &lhs,
                  VkRenderPassInputAttachmentAspectCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceSurfaceInfo2KHR const &lhs,
                  VkPhysicalDeviceSurfaceInfo2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.surface == rhs.surface);
  }
  
  bool operator!=(VkPhysicalDeviceSurfaceInfo2KHR const &lhs,
                  VkPhysicalDeviceSurfaceInfo2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSurfaceCapabilities2KHR const &lhs,
                  VkSurfaceCapabilities2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.surfaceCapabilities == rhs.surfaceCapabilities);
  }
  
  bool operator!=(VkSurfaceCapabilities2KHR const &lhs,
                  VkSurfaceCapabilities2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSurfaceFormat2KHR const &lhs,
                  VkSurfaceFormat2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.surfaceFormat == rhs.surfaceFormat);
  }
  
  bool operator!=(VkSurfaceFormat2KHR const &lhs,
                  VkSurfaceFormat2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayProperties2KHR const &lhs,
                  VkDisplayProperties2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.displayProperties == rhs.displayProperties);
  }
  
  bool operator!=(VkDisplayProperties2KHR const &lhs,
                  VkDisplayProperties2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayPlaneProperties2KHR const &lhs,
                  VkDisplayPlaneProperties2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.displayPlaneProperties == rhs.displayPlaneProperties);
  }
  
  bool operator!=(VkDisplayPlaneProperties2KHR const &lhs,
                  VkDisplayPlaneProperties2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayModeProperties2KHR const &lhs,
                  VkDisplayModeProperties2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.displayModeProperties == rhs.displayModeProperties);
  }
  
  bool operator!=(VkDisplayModeProperties2KHR const &lhs,
                  VkDisplayModeProperties2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayPlaneInfo2KHR const &lhs,
                  VkDisplayPlaneInfo2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.mode == rhs.mode) &&
           (lhs.planeIndex == rhs.planeIndex);
  }
  
  bool operator!=(VkDisplayPlaneInfo2KHR const &lhs,
                  VkDisplayPlaneInfo2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDisplayPlaneCapabilities2KHR const &lhs,
                  VkDisplayPlaneCapabilities2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.capabilities == rhs.capabilities);
  }
  
  bool operator!=(VkDisplayPlaneCapabilities2KHR const &lhs,
                  VkDisplayPlaneCapabilities2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSharedPresentSurfaceCapabilitiesKHR const &lhs,
                  VkSharedPresentSurfaceCapabilitiesKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags);
  }
  
  bool operator!=(VkSharedPresentSurfaceCapabilitiesKHR const &lhs,
                  VkSharedPresentSurfaceCapabilitiesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDevice16BitStorageFeatures const &lhs,
                  VkPhysicalDevice16BitStorageFeatures const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.storageBuffer16BitAccess == rhs.storageBuffer16BitAccess) &&
           (lhs.uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess) &&
           (lhs.storagePushConstant16 == rhs.storagePushConstant16) &&
           (lhs.storageInputOutput16 == rhs.storageInputOutput16);
  }
  
  bool operator!=(VkPhysicalDevice16BitStorageFeatures const &lhs,
                  VkPhysicalDevice16BitStorageFeatures const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceSubgroupProperties const &lhs,
                  VkPhysicalDeviceSubgroupProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.subgroupSize == rhs.subgroupSize) &&
           (lhs.supportedStages == rhs.supportedStages) &&
           (lhs.supportedOperations == rhs.supportedOperations) &&
           (lhs.quadOperationsInAllStages == rhs.quadOperationsInAllStages);
  }
  
  bool operator!=(VkPhysicalDeviceSubgroupProperties const &lhs,
                  VkPhysicalDeviceSubgroupProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBufferMemoryRequirementsInfo2 const &lhs,
                  VkBufferMemoryRequirementsInfo2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.buffer == rhs.buffer);
  }
  
  bool operator!=(VkBufferMemoryRequirementsInfo2 const &lhs,
                  VkBufferMemoryRequirementsInfo2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageMemoryRequirementsInfo2 const &lhs,
                  VkImageMemoryRequirementsInfo2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.image == rhs.image);
  }
  
  bool operator!=(VkImageMemoryRequirementsInfo2 const &lhs,
                  VkImageMemoryRequirementsInfo2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageSparseMemoryRequirementsInfo2 const &lhs,
                  VkImageSparseMemoryRequirementsInfo2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.image == rhs.image);
  }
  
  bool operator!=(VkImageSparseMemoryRequirementsInfo2 const &lhs,
                  VkImageSparseMemoryRequirementsInfo2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryRequirements2 const &lhs,
                  VkMemoryRequirements2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memoryRequirements == rhs.memoryRequirements);
  }
  
  bool operator!=(VkMemoryRequirements2 const &lhs,
                  VkMemoryRequirements2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSparseImageMemoryRequirements2 const &lhs,
                  VkSparseImageMemoryRequirements2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memoryRequirements == rhs.memoryRequirements);
  }
  
  bool operator!=(VkSparseImageMemoryRequirements2 const &lhs,
                  VkSparseImageMemoryRequirements2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDevicePointClippingProperties const &lhs,
                  VkPhysicalDevicePointClippingProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.pointClippingBehavior == rhs.pointClippingBehavior);
  }
  
  bool operator!=(VkPhysicalDevicePointClippingProperties const &lhs,
                  VkPhysicalDevicePointClippingProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryDedicatedRequirements const &lhs,
                  VkMemoryDedicatedRequirements const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.prefersDedicatedAllocation == rhs.prefersDedicatedAllocation) &&
           (lhs.requiresDedicatedAllocation == rhs.requiresDedicatedAllocation);
  }
  
  bool operator!=(VkMemoryDedicatedRequirements const &lhs,
                  VkMemoryDedicatedRequirements const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryDedicatedAllocateInfo const &lhs,
                  VkMemoryDedicatedAllocateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.image == rhs.image) &&
           (lhs.buffer == rhs.buffer);
  }
  
  bool operator!=(VkMemoryDedicatedAllocateInfo const &lhs,
                  VkMemoryDedicatedAllocateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageViewUsageCreateInfo const &lhs,
                  VkImageViewUsageCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.usage == rhs.usage);
  }
  
  bool operator!=(VkImageViewUsageCreateInfo const &lhs,
                  VkImageViewUsageCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineTessellationDomainOriginStateCreateInfo const &lhs,
                  VkPipelineTessellationDomainOriginStateCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.domainOrigin == rhs.domainOrigin);
  }
  
  bool operator!=(VkPipelineTessellationDomainOriginStateCreateInfo const &lhs,
                  VkPipelineTessellationDomainOriginStateCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSamplerYcbcrConversionInfo const &lhs,
                  VkSamplerYcbcrConversionInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.conversion == rhs.conversion);
  }
  
  bool operator!=(VkSamplerYcbcrConversionInfo const &lhs,
                  VkSamplerYcbcrConversionInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSamplerYcbcrConversionCreateInfo const &lhs,
                  VkSamplerYcbcrConversionCreateInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.format == rhs.format) &&
           (lhs.ycbcrModel == rhs.ycbcrModel) &&
           (lhs.ycbcrRange == rhs.ycbcrRange) &&
           (lhs.components == rhs.components) &&
           (lhs.xChromaOffset == rhs.xChromaOffset) &&
           (lhs.yChromaOffset == rhs.yChromaOffset) &&
           (lhs.chromaFilter == rhs.chromaFilter) &&
           (lhs.forceExplicitReconstruction == rhs.forceExplicitReconstruction);
  }
  
  bool operator!=(VkSamplerYcbcrConversionCreateInfo const &lhs,
                  VkSamplerYcbcrConversionCreateInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBindImagePlaneMemoryInfo const &lhs,
                  VkBindImagePlaneMemoryInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.planeAspect == rhs.planeAspect);
  }
  
  bool operator!=(VkBindImagePlaneMemoryInfo const &lhs,
                  VkBindImagePlaneMemoryInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImagePlaneMemoryRequirementsInfo const &lhs,
                  VkImagePlaneMemoryRequirementsInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.planeAspect == rhs.planeAspect);
  }
  
  bool operator!=(VkImagePlaneMemoryRequirementsInfo const &lhs,
                  VkImagePlaneMemoryRequirementsInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceSamplerYcbcrConversionFeatures const &lhs,
                  VkPhysicalDeviceSamplerYcbcrConversionFeatures const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.samplerYcbcrConversion == rhs.samplerYcbcrConversion);
  }
  
  bool operator!=(VkPhysicalDeviceSamplerYcbcrConversionFeatures const &lhs,
                  VkPhysicalDeviceSamplerYcbcrConversionFeatures const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSamplerYcbcrConversionImageFormatProperties const &lhs,
                  VkSamplerYcbcrConversionImageFormatProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount);
  }
  
  bool operator!=(VkSamplerYcbcrConversionImageFormatProperties const &lhs,
                  VkSamplerYcbcrConversionImageFormatProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkTextureLODGatherFormatPropertiesAMD const &lhs,
                  VkTextureLODGatherFormatPropertiesAMD const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD);
  }
  
  bool operator!=(VkTextureLODGatherFormatPropertiesAMD const &lhs,
                  VkTextureLODGatherFormatPropertiesAMD const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkConditionalRenderingBeginInfoEXT const &lhs,
                  VkConditionalRenderingBeginInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.buffer == rhs.buffer) &&
           (lhs.offset == rhs.offset) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkConditionalRenderingBeginInfoEXT const &lhs,
                  VkConditionalRenderingBeginInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkProtectedSubmitInfo const &lhs,
                  VkProtectedSubmitInfo const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.protectedSubmit == rhs.protectedSubmit);
  }
  
  bool operator!=(VkProtectedSubmitInfo const &lhs,
                  VkProtectedSubmitInfo const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceProtectedMemoryFeatures const &lhs,
                  VkPhysicalDeviceProtectedMemoryFeatures const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.protectedMemory == rhs.protectedMemory);
  }
  
  bool operator!=(VkPhysicalDeviceProtectedMemoryFeatures const &lhs,
                  VkPhysicalDeviceProtectedMemoryFeatures const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceProtectedMemoryProperties const &lhs,
                  VkPhysicalDeviceProtectedMemoryProperties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.protectedNoFault == rhs.protectedNoFault);
  }
  
  bool operator!=(VkPhysicalDeviceProtectedMemoryProperties const &lhs,
                  VkPhysicalDeviceProtectedMemoryProperties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceQueueInfo2 const &lhs,
                  VkDeviceQueueInfo2 const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.queueFamilyIndex == rhs.queueFamilyIndex) &&
           (lhs.queueIndex == rhs.queueIndex);
  }
  
  bool operator!=(VkDeviceQueueInfo2 const &lhs,
                  VkDeviceQueueInfo2 const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineCoverageToColorStateCreateInfoNV const &lhs,
                  VkPipelineCoverageToColorStateCreateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.coverageToColorEnable == rhs.coverageToColorEnable) &&
           (lhs.coverageToColorLocation == rhs.coverageToColorLocation);
  }
  
  bool operator!=(VkPipelineCoverageToColorStateCreateInfoNV const &lhs,
                  VkPipelineCoverageToColorStateCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &lhs,
                  VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats) &&
           (lhs.filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping);
  }
  
  bool operator!=(VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &lhs,
                  VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSampleLocationEXT const &lhs,
                  VkSampleLocationEXT const &rhs) noexcept {
    return (lhs.x == rhs.x) &&
           (lhs.y == rhs.y);
  }
  
  bool operator!=(VkSampleLocationEXT const &lhs,
                  VkSampleLocationEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSampleLocationsInfoEXT const &lhs,
                  VkSampleLocationsInfoEXT const &rhs) noexcept {
    if(lhs.sampleLocationsCount != rhs.sampleLocationsCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.sampleLocationsCount; ++i) {
      if(lhs.pSampleLocations[i] != rhs.pSampleLocations[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.sampleLocationsPerPixel == rhs.sampleLocationsPerPixel) &&
           (lhs.sampleLocationGridSize == rhs.sampleLocationGridSize);
  }
  
  bool operator!=(VkSampleLocationsInfoEXT const &lhs,
                  VkSampleLocationsInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAttachmentSampleLocationsEXT const &lhs,
                  VkAttachmentSampleLocationsEXT const &rhs) noexcept {
    return (lhs.attachmentIndex == rhs.attachmentIndex) &&
           (lhs.sampleLocationsInfo == rhs.sampleLocationsInfo);
  }
  
  bool operator!=(VkAttachmentSampleLocationsEXT const &lhs,
                  VkAttachmentSampleLocationsEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubpassSampleLocationsEXT const &lhs,
                  VkSubpassSampleLocationsEXT const &rhs) noexcept {
    return (lhs.subpassIndex == rhs.subpassIndex) &&
           (lhs.sampleLocationsInfo == rhs.sampleLocationsInfo);
  }
  
  bool operator!=(VkSubpassSampleLocationsEXT const &lhs,
                  VkSubpassSampleLocationsEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRenderPassSampleLocationsBeginInfoEXT const &lhs,
                  VkRenderPassSampleLocationsBeginInfoEXT const &rhs) noexcept {
    if(lhs.attachmentInitialSampleLocationsCount != rhs.attachmentInitialSampleLocationsCount)
      return false;
  
    if(lhs.postSubpassSampleLocationsCount != rhs.postSubpassSampleLocationsCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.attachmentInitialSampleLocationsCount; ++i) {
      if(lhs.pAttachmentInitialSampleLocations[i] != rhs.pAttachmentInitialSampleLocations[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.postSubpassSampleLocationsCount; ++i) {
      if(lhs.pPostSubpassSampleLocations[i] != rhs.pPostSubpassSampleLocations[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkRenderPassSampleLocationsBeginInfoEXT const &lhs,
                  VkRenderPassSampleLocationsBeginInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineSampleLocationsStateCreateInfoEXT const &lhs,
                  VkPipelineSampleLocationsStateCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.sampleLocationsEnable == rhs.sampleLocationsEnable) &&
           (lhs.sampleLocationsInfo == rhs.sampleLocationsInfo);
  }
  
  bool operator!=(VkPipelineSampleLocationsStateCreateInfoEXT const &lhs,
                  VkPipelineSampleLocationsStateCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceSampleLocationsPropertiesEXT const &lhs,
                  VkPhysicalDeviceSampleLocationsPropertiesEXT const &rhs) noexcept {
    for(uint32_t i = 0; i < 2; ++i) {
      if(lhs.sampleLocationCoordinateRange[i] != rhs.sampleLocationCoordinateRange[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.sampleLocationSampleCounts == rhs.sampleLocationSampleCounts) &&
           (lhs.maxSampleLocationGridSize == rhs.maxSampleLocationGridSize) &&
           (lhs.sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits) &&
           (lhs.variableSampleLocations == rhs.variableSampleLocations);
  }
  
  bool operator!=(VkPhysicalDeviceSampleLocationsPropertiesEXT const &lhs,
                  VkPhysicalDeviceSampleLocationsPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMultisamplePropertiesEXT const &lhs,
                  VkMultisamplePropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxSampleLocationGridSize == rhs.maxSampleLocationGridSize);
  }
  
  bool operator!=(VkMultisamplePropertiesEXT const &lhs,
                  VkMultisamplePropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSamplerReductionModeCreateInfoEXT const &lhs,
                  VkSamplerReductionModeCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.reductionMode == rhs.reductionMode);
  }
  
  bool operator!=(VkSamplerReductionModeCreateInfoEXT const &lhs,
                  VkSamplerReductionModeCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &lhs,
                  VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations);
  }
  
  bool operator!=(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &lhs,
                  VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &lhs,
                  VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments) &&
           (lhs.advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend) &&
           (lhs.advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor) &&
           (lhs.advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor) &&
           (lhs.advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap) &&
           (lhs.advancedBlendAllOperations == rhs.advancedBlendAllOperations);
  }
  
  bool operator!=(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &lhs,
                  VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineColorBlendAdvancedStateCreateInfoEXT const &lhs,
                  VkPipelineColorBlendAdvancedStateCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.srcPremultiplied == rhs.srcPremultiplied) &&
           (lhs.dstPremultiplied == rhs.dstPremultiplied) &&
           (lhs.blendOverlap == rhs.blendOverlap);
  }
  
  bool operator!=(VkPipelineColorBlendAdvancedStateCreateInfoEXT const &lhs,
                  VkPipelineColorBlendAdvancedStateCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &lhs,
                  VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.inlineUniformBlock == rhs.inlineUniformBlock) &&
           (lhs.descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind);
  }
  
  bool operator!=(VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &lhs,
                  VkPhysicalDeviceInlineUniformBlockFeaturesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &lhs,
                  VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize) &&
           (lhs.maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks) &&
           (lhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks) &&
           (lhs.maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks) &&
           (lhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks);
  }
  
  bool operator!=(VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &lhs,
                  VkPhysicalDeviceInlineUniformBlockPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkWriteDescriptorSetInlineUniformBlockEXT const &lhs,
                  VkWriteDescriptorSetInlineUniformBlockEXT const &rhs) noexcept {
    if(lhs.dataSize != rhs.dataSize)
      return false;
  
    if(memcmp(lhs.pData, rhs.pData, lhs.dataSize) != 0)
      return false;
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkWriteDescriptorSetInlineUniformBlockEXT const &lhs,
                  VkWriteDescriptorSetInlineUniformBlockEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &lhs,
                  VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings);
  }
  
  bool operator!=(VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &lhs,
                  VkDescriptorPoolInlineUniformBlockCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineCoverageModulationStateCreateInfoNV const &lhs,
                  VkPipelineCoverageModulationStateCreateInfoNV const &rhs) noexcept {
    if(lhs.coverageModulationTableCount != rhs.coverageModulationTableCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.coverageModulationTableCount; ++i) {
      if(lhs.pCoverageModulationTable[i] != rhs.pCoverageModulationTable[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.coverageModulationMode == rhs.coverageModulationMode) &&
           (lhs.coverageModulationTableEnable == rhs.coverageModulationTableEnable);
  }
  
  bool operator!=(VkPipelineCoverageModulationStateCreateInfoNV const &lhs,
                  VkPipelineCoverageModulationStateCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageFormatListCreateInfoKHR const &lhs,
                  VkImageFormatListCreateInfoKHR const &rhs) noexcept {
    if(lhs.viewFormatCount != rhs.viewFormatCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.viewFormatCount; ++i) {
      if(lhs.pViewFormats[i] != rhs.pViewFormats[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkImageFormatListCreateInfoKHR const &lhs,
                  VkImageFormatListCreateInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkValidationCacheCreateInfoEXT const &lhs,
                  VkValidationCacheCreateInfoEXT const &rhs) noexcept {
    if(lhs.initialDataSize != rhs.initialDataSize)
      return false;
  
    if(memcmp(lhs.pInitialData, rhs.pInitialData, lhs.initialDataSize) != 0)
      return false;
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkValidationCacheCreateInfoEXT const &lhs,
                  VkValidationCacheCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkShaderModuleValidationCacheCreateInfoEXT const &lhs,
                  VkShaderModuleValidationCacheCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.validationCache == rhs.validationCache);
  }
  
  bool operator!=(VkShaderModuleValidationCacheCreateInfoEXT const &lhs,
                  VkShaderModuleValidationCacheCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceMaintenance3Properties const &lhs,
                  VkPhysicalDeviceMaintenance3Properties const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxPerSetDescriptors == rhs.maxPerSetDescriptors) &&
           (lhs.maxMemoryAllocationSize == rhs.maxMemoryAllocationSize);
  }
  
  bool operator!=(VkPhysicalDeviceMaintenance3Properties const &lhs,
                  VkPhysicalDeviceMaintenance3Properties const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorSetLayoutSupport const &lhs,
                  VkDescriptorSetLayoutSupport const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.supported == rhs.supported);
  }
  
  bool operator!=(VkDescriptorSetLayoutSupport const &lhs,
                  VkDescriptorSetLayoutSupport const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceShaderDrawParameterFeatures const &lhs,
                  VkPhysicalDeviceShaderDrawParameterFeatures const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.shaderDrawParameters == rhs.shaderDrawParameters);
  }
  
  bool operator!=(VkPhysicalDeviceShaderDrawParameterFeatures const &lhs,
                  VkPhysicalDeviceShaderDrawParameterFeatures const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkNativeBufferANDROID const &lhs,
                  VkNativeBufferANDROID const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handle == rhs.handle) &&
           (lhs.stride == rhs.stride) &&
           (lhs.format == rhs.format) &&
           (lhs.usage == rhs.usage);
  }
  
  bool operator!=(VkNativeBufferANDROID const &lhs,
                  VkNativeBufferANDROID const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  bool operator==(VkShaderResourceUsageAMD const &lhs,
                  VkShaderResourceUsageAMD const &rhs) noexcept {
    return (lhs.numUsedVgprs == rhs.numUsedVgprs) &&
           (lhs.numUsedSgprs == rhs.numUsedSgprs) &&
           (lhs.ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup) &&
           (lhs.ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes) &&
           (lhs.scratchMemUsageInBytes == rhs.scratchMemUsageInBytes);
  }
  
  bool operator!=(VkShaderResourceUsageAMD const &lhs,
                  VkShaderResourceUsageAMD const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkShaderStatisticsInfoAMD const &lhs,
                  VkShaderStatisticsInfoAMD const &rhs) noexcept {
    for(uint32_t i = 0; i < 3; ++i) {
      if(lhs.computeWorkGroupSize[i] != rhs.computeWorkGroupSize[i])
        return false;
    }
  
    return (lhs.shaderStageMask == rhs.shaderStageMask) &&
           (lhs.resourceUsage == rhs.resourceUsage) &&
           (lhs.numPhysicalVgprs == rhs.numPhysicalVgprs) &&
           (lhs.numPhysicalSgprs == rhs.numPhysicalSgprs) &&
           (lhs.numAvailableVgprs == rhs.numAvailableVgprs) &&
           (lhs.numAvailableSgprs == rhs.numAvailableSgprs);
  }
  
  bool operator!=(VkShaderStatisticsInfoAMD const &lhs,
                  VkShaderStatisticsInfoAMD const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceQueueGlobalPriorityCreateInfoEXT const &lhs,
                  VkDeviceQueueGlobalPriorityCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.globalPriority == rhs.globalPriority);
  }
  
  bool operator!=(VkDeviceQueueGlobalPriorityCreateInfoEXT const &lhs,
                  VkDeviceQueueGlobalPriorityCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugUtilsObjectNameInfoEXT const &lhs,
                  VkDebugUtilsObjectNameInfoEXT const &rhs) noexcept {
    if (lhs.pObjectName != rhs.pObjectName) {
      if(lhs.pObjectName == nullptr || rhs.pObjectName == nullptr)
        return false;
      if(strcmp(lhs.pObjectName, rhs.pObjectName) != 0)
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.objectType == rhs.objectType) &&
           (lhs.objectHandle == rhs.objectHandle);
  }
  
  bool operator!=(VkDebugUtilsObjectNameInfoEXT const &lhs,
                  VkDebugUtilsObjectNameInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugUtilsObjectTagInfoEXT const &lhs,
                  VkDebugUtilsObjectTagInfoEXT const &rhs) noexcept {
    if(lhs.tagSize != rhs.tagSize)
      return false;
  
    if(memcmp(lhs.pTag, rhs.pTag, lhs.tagSize) != 0)
      return false;
  
    return (lhs.sType == rhs.sType) &&
           (lhs.objectType == rhs.objectType) &&
           (lhs.objectHandle == rhs.objectHandle) &&
           (lhs.tagName == rhs.tagName);
  }
  
  bool operator!=(VkDebugUtilsObjectTagInfoEXT const &lhs,
                  VkDebugUtilsObjectTagInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugUtilsLabelEXT const &lhs,
                  VkDebugUtilsLabelEXT const &rhs) noexcept {
    if (lhs.pLabelName != rhs.pLabelName) {
      if(lhs.pLabelName == nullptr || rhs.pLabelName == nullptr)
        return false;
      if(strcmp(lhs.pLabelName, rhs.pLabelName) != 0)
        return false;
    }
  
    for(uint32_t i = 0; i < 4; ++i) {
      if(lhs.color[i] != rhs.color[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkDebugUtilsLabelEXT const &lhs,
                  VkDebugUtilsLabelEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugUtilsMessengerCreateInfoEXT const &lhs,
                  VkDebugUtilsMessengerCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.messageSeverity == rhs.messageSeverity) &&
           (lhs.messageType == rhs.messageType) &&
           (lhs.pfnUserCallback == rhs.pfnUserCallback) &&
           (lhs.pUserData == rhs.pUserData);
  }
  
  bool operator!=(VkDebugUtilsMessengerCreateInfoEXT const &lhs,
                  VkDebugUtilsMessengerCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDebugUtilsMessengerCallbackDataEXT const &lhs,
                  VkDebugUtilsMessengerCallbackDataEXT const &rhs) noexcept {
    if(lhs.queueLabelCount != rhs.queueLabelCount)
      return false;
  
    if(lhs.cmdBufLabelCount != rhs.cmdBufLabelCount)
      return false;
  
    if(lhs.objectCount != rhs.objectCount)
      return false;
  
    if (lhs.pMessageIdName != rhs.pMessageIdName) {
      if(lhs.pMessageIdName == nullptr || rhs.pMessageIdName == nullptr)
        return false;
      if(strcmp(lhs.pMessageIdName, rhs.pMessageIdName) != 0)
        return false;
    }
  
    if (lhs.pMessage != rhs.pMessage) {
      if(lhs.pMessage == nullptr || rhs.pMessage == nullptr)
        return false;
      if(strcmp(lhs.pMessage, rhs.pMessage) != 0)
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.queueLabelCount; ++i) {
      if(lhs.pQueueLabels[i] != rhs.pQueueLabels[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.cmdBufLabelCount; ++i) {
      if(lhs.pCmdBufLabels[i] != rhs.pCmdBufLabels[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.objectCount; ++i) {
      if(lhs.pObjects[i] != rhs.pObjects[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.messageIdNumber == rhs.messageIdNumber);
  }
  
  bool operator!=(VkDebugUtilsMessengerCallbackDataEXT const &lhs,
                  VkDebugUtilsMessengerCallbackDataEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImportMemoryHostPointerInfoEXT const &lhs,
                  VkImportMemoryHostPointerInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.handleType == rhs.handleType) &&
           (lhs.pHostPointer == rhs.pHostPointer);
  }
  
  bool operator!=(VkImportMemoryHostPointerInfoEXT const &lhs,
                  VkImportMemoryHostPointerInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkMemoryHostPointerPropertiesEXT const &lhs,
                  VkMemoryHostPointerPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memoryTypeBits == rhs.memoryTypeBits);
  }
  
  bool operator!=(VkMemoryHostPointerPropertiesEXT const &lhs,
                  VkMemoryHostPointerPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &lhs,
                  VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment);
  }
  
  bool operator!=(VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &lhs,
                  VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &lhs,
                  VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.primitiveOverestimationSize == rhs.primitiveOverestimationSize) &&
           (lhs.maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize) &&
           (lhs.extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity) &&
           (lhs.primitiveUnderestimation == rhs.primitiveUnderestimation) &&
           (lhs.conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization) &&
           (lhs.degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized) &&
           (lhs.degenerateLinesRasterized == rhs.degenerateLinesRasterized) &&
           (lhs.fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable) &&
           (lhs.conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage);
  }
  
  bool operator!=(VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &lhs,
                  VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCalibratedTimestampInfoEXT const &lhs,
                  VkCalibratedTimestampInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.timeDomain == rhs.timeDomain);
  }
  
  bool operator!=(VkCalibratedTimestampInfoEXT const &lhs,
                  VkCalibratedTimestampInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceShaderCorePropertiesAMD const &lhs,
                  VkPhysicalDeviceShaderCorePropertiesAMD const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.shaderEngineCount == rhs.shaderEngineCount) &&
           (lhs.shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount) &&
           (lhs.computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray) &&
           (lhs.simdPerComputeUnit == rhs.simdPerComputeUnit) &&
           (lhs.wavefrontsPerSimd == rhs.wavefrontsPerSimd) &&
           (lhs.wavefrontSize == rhs.wavefrontSize) &&
           (lhs.sgprsPerSimd == rhs.sgprsPerSimd) &&
           (lhs.minSgprAllocation == rhs.minSgprAllocation) &&
           (lhs.maxSgprAllocation == rhs.maxSgprAllocation) &&
           (lhs.sgprAllocationGranularity == rhs.sgprAllocationGranularity) &&
           (lhs.vgprsPerSimd == rhs.vgprsPerSimd) &&
           (lhs.minVgprAllocation == rhs.minVgprAllocation) &&
           (lhs.maxVgprAllocation == rhs.maxVgprAllocation) &&
           (lhs.vgprAllocationGranularity == rhs.vgprAllocationGranularity);
  }
  
  bool operator!=(VkPhysicalDeviceShaderCorePropertiesAMD const &lhs,
                  VkPhysicalDeviceShaderCorePropertiesAMD const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineRasterizationConservativeStateCreateInfoEXT const &lhs,
                  VkPipelineRasterizationConservativeStateCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.conservativeRasterizationMode == rhs.conservativeRasterizationMode) &&
           (lhs.extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize);
  }
  
  bool operator!=(VkPipelineRasterizationConservativeStateCreateInfoEXT const &lhs,
                  VkPipelineRasterizationConservativeStateCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &lhs,
                  VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing) &&
           (lhs.shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing) &&
           (lhs.shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing) &&
           (lhs.shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing) &&
           (lhs.shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing) &&
           (lhs.shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing) &&
           (lhs.shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing) &&
           (lhs.shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing) &&
           (lhs.shaderUniformTexelBufferArrayNonUniformIndexing == rhs.shaderUniformTexelBufferArrayNonUniformIndexing) &&
           (lhs.shaderStorageTexelBufferArrayNonUniformIndexing == rhs.shaderStorageTexelBufferArrayNonUniformIndexing) &&
           (lhs.descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind) &&
           (lhs.descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind) &&
           (lhs.descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind) &&
           (lhs.descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind) &&
           (lhs.descriptorBindingUniformTexelBufferUpdateAfterBind == rhs.descriptorBindingUniformTexelBufferUpdateAfterBind) &&
           (lhs.descriptorBindingStorageTexelBufferUpdateAfterBind == rhs.descriptorBindingStorageTexelBufferUpdateAfterBind) &&
           (lhs.descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending) &&
           (lhs.descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound) &&
           (lhs.descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount) &&
           (lhs.runtimeDescriptorArray == rhs.runtimeDescriptorArray);
  }
  
  bool operator!=(VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &lhs,
                  VkPhysicalDeviceDescriptorIndexingFeaturesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceDescriptorIndexingPropertiesEXT const &lhs,
                  VkPhysicalDeviceDescriptorIndexingPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools) &&
           (lhs.shaderUniformBufferArrayNonUniformIndexingNative == rhs.shaderUniformBufferArrayNonUniformIndexingNative) &&
           (lhs.shaderSampledImageArrayNonUniformIndexingNative == rhs.shaderSampledImageArrayNonUniformIndexingNative) &&
           (lhs.shaderStorageBufferArrayNonUniformIndexingNative == rhs.shaderStorageBufferArrayNonUniformIndexingNative) &&
           (lhs.shaderStorageImageArrayNonUniformIndexingNative == rhs.shaderStorageImageArrayNonUniformIndexingNative) &&
           (lhs.shaderInputAttachmentArrayNonUniformIndexingNative == rhs.shaderInputAttachmentArrayNonUniformIndexingNative) &&
           (lhs.robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind) &&
           (lhs.quadDivergentImplicitLod == rhs.quadDivergentImplicitLod) &&
           (lhs.maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers) &&
           (lhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers == rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers) &&
           (lhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers == rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers) &&
           (lhs.maxPerStageDescriptorUpdateAfterBindSampledImages == rhs.maxPerStageDescriptorUpdateAfterBindSampledImages) &&
           (lhs.maxPerStageDescriptorUpdateAfterBindStorageImages == rhs.maxPerStageDescriptorUpdateAfterBindStorageImages) &&
           (lhs.maxPerStageDescriptorUpdateAfterBindInputAttachments == rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments) &&
           (lhs.maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources) &&
           (lhs.maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers) &&
           (lhs.maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers) &&
           (lhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic) &&
           (lhs.maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers) &&
           (lhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic) &&
           (lhs.maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages) &&
           (lhs.maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages) &&
           (lhs.maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments);
  }
  
  bool operator!=(VkPhysicalDeviceDescriptorIndexingPropertiesEXT const &lhs,
                  VkPhysicalDeviceDescriptorIndexingPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &lhs,
                  VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &rhs) noexcept {
    if(lhs.bindingCount != rhs.bindingCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.bindingCount; ++i) {
      if(lhs.pBindingFlags[i] != rhs.pBindingFlags[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &lhs,
                  VkDescriptorSetLayoutBindingFlagsCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &lhs,
                  VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &rhs) noexcept {
    if(lhs.descriptorSetCount != rhs.descriptorSetCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.descriptorSetCount; ++i) {
      if(lhs.pDescriptorCounts[i] != rhs.pDescriptorCounts[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &lhs,
                  VkDescriptorSetVariableDescriptorCountAllocateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const &lhs,
                  VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxVariableDescriptorCount == rhs.maxVariableDescriptorCount);
  }
  
  bool operator!=(VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const &lhs,
                  VkDescriptorSetVariableDescriptorCountLayoutSupportEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAttachmentDescription2KHR const &lhs,
                  VkAttachmentDescription2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.format == rhs.format) &&
           (lhs.samples == rhs.samples) &&
           (lhs.loadOp == rhs.loadOp) &&
           (lhs.storeOp == rhs.storeOp) &&
           (lhs.stencilLoadOp == rhs.stencilLoadOp) &&
           (lhs.stencilStoreOp == rhs.stencilStoreOp) &&
           (lhs.initialLayout == rhs.initialLayout) &&
           (lhs.finalLayout == rhs.finalLayout);
  }
  
  bool operator!=(VkAttachmentDescription2KHR const &lhs,
                  VkAttachmentDescription2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAttachmentReference2KHR const &lhs,
                  VkAttachmentReference2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.attachment == rhs.attachment) &&
           (lhs.layout == rhs.layout) &&
           (lhs.aspectMask == rhs.aspectMask);
  }
  
  bool operator!=(VkAttachmentReference2KHR const &lhs,
                  VkAttachmentReference2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubpassDescription2KHR const &lhs,
                  VkSubpassDescription2KHR const &rhs) noexcept {
    if(lhs.inputAttachmentCount != rhs.inputAttachmentCount)
      return false;
  
    if(lhs.colorAttachmentCount != rhs.colorAttachmentCount)
      return false;
  
    if(lhs.colorAttachmentCount != rhs.colorAttachmentCount)
      return false;
  
    if(lhs.preserveAttachmentCount != rhs.preserveAttachmentCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.inputAttachmentCount; ++i) {
      if(lhs.pInputAttachments[i] != rhs.pInputAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.colorAttachmentCount; ++i) {
      if(lhs.pColorAttachments[i] != rhs.pColorAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.colorAttachmentCount; ++i) {
      if(lhs.pResolveAttachments[i] != rhs.pResolveAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.preserveAttachmentCount; ++i) {
      if(lhs.pPreserveAttachments[i] != rhs.pPreserveAttachments[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.pipelineBindPoint == rhs.pipelineBindPoint) &&
           (lhs.viewMask == rhs.viewMask) &&
           (lhs.pDepthStencilAttachment == rhs.pDepthStencilAttachment);
  }
  
  bool operator!=(VkSubpassDescription2KHR const &lhs,
                  VkSubpassDescription2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubpassDependency2KHR const &lhs,
                  VkSubpassDependency2KHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.srcSubpass == rhs.srcSubpass) &&
           (lhs.dstSubpass == rhs.dstSubpass) &&
           (lhs.srcStageMask == rhs.srcStageMask) &&
           (lhs.dstStageMask == rhs.dstStageMask) &&
           (lhs.srcAccessMask == rhs.srcAccessMask) &&
           (lhs.dstAccessMask == rhs.dstAccessMask) &&
           (lhs.dependencyFlags == rhs.dependencyFlags) &&
           (lhs.viewOffset == rhs.viewOffset);
  }
  
  bool operator!=(VkSubpassDependency2KHR const &lhs,
                  VkSubpassDependency2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRenderPassCreateInfo2KHR const &lhs,
                  VkRenderPassCreateInfo2KHR const &rhs) noexcept {
    if(lhs.attachmentCount != rhs.attachmentCount)
      return false;
  
    if(lhs.subpassCount != rhs.subpassCount)
      return false;
  
    if(lhs.dependencyCount != rhs.dependencyCount)
      return false;
  
    if(lhs.correlatedViewMaskCount != rhs.correlatedViewMaskCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.attachmentCount; ++i) {
      if(lhs.pAttachments[i] != rhs.pAttachments[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.subpassCount; ++i) {
      if(lhs.pSubpasses[i] != rhs.pSubpasses[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.dependencyCount; ++i) {
      if(lhs.pDependencies[i] != rhs.pDependencies[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.correlatedViewMaskCount; ++i) {
      if(lhs.pCorrelatedViewMasks[i] != rhs.pCorrelatedViewMasks[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkRenderPassCreateInfo2KHR const &lhs,
                  VkRenderPassCreateInfo2KHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubpassBeginInfoKHR const &lhs,
                  VkSubpassBeginInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.contents == rhs.contents);
  }
  
  bool operator!=(VkSubpassBeginInfoKHR const &lhs,
                  VkSubpassBeginInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkSubpassEndInfoKHR const &lhs,
                  VkSubpassEndInfoKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkSubpassEndInfoKHR const &lhs,
                  VkSubpassEndInfoKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkVertexInputBindingDivisorDescriptionEXT const &lhs,
                  VkVertexInputBindingDivisorDescriptionEXT const &rhs) noexcept {
    return (lhs.binding == rhs.binding) &&
           (lhs.divisor == rhs.divisor);
  }
  
  bool operator!=(VkVertexInputBindingDivisorDescriptionEXT const &lhs,
                  VkVertexInputBindingDivisorDescriptionEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineVertexInputDivisorStateCreateInfoEXT const &lhs,
                  VkPipelineVertexInputDivisorStateCreateInfoEXT const &rhs) noexcept {
    if(lhs.vertexBindingDivisorCount != rhs.vertexBindingDivisorCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.vertexBindingDivisorCount; ++i) {
      if(lhs.pVertexBindingDivisors[i] != rhs.pVertexBindingDivisors[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkPipelineVertexInputDivisorStateCreateInfoEXT const &lhs,
                  VkPipelineVertexInputDivisorStateCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &lhs,
                  VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxVertexAttribDivisor == rhs.maxVertexAttribDivisor);
  }
  
  bool operator!=(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &lhs,
                  VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDevicePCIBusInfoPropertiesEXT const &lhs,
                  VkPhysicalDevicePCIBusInfoPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.pciDomain == rhs.pciDomain) &&
           (lhs.pciBus == rhs.pciBus) &&
           (lhs.pciDevice == rhs.pciDevice) &&
           (lhs.pciFunction == rhs.pciFunction);
  }
  
  bool operator!=(VkPhysicalDevicePCIBusInfoPropertiesEXT const &lhs,
                  VkPhysicalDevicePCIBusInfoPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkImportAndroidHardwareBufferInfoANDROID const &lhs,
                  VkImportAndroidHardwareBufferInfoANDROID const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.buffer == rhs.buffer);
  }
  
  bool operator!=(VkImportAndroidHardwareBufferInfoANDROID const &lhs,
                  VkImportAndroidHardwareBufferInfoANDROID const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkAndroidHardwareBufferUsageANDROID const &lhs,
                  VkAndroidHardwareBufferUsageANDROID const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.androidHardwareBufferUsage == rhs.androidHardwareBufferUsage);
  }
  
  bool operator!=(VkAndroidHardwareBufferUsageANDROID const &lhs,
                  VkAndroidHardwareBufferUsageANDROID const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkAndroidHardwareBufferPropertiesANDROID const &lhs,
                  VkAndroidHardwareBufferPropertiesANDROID const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.allocationSize == rhs.allocationSize) &&
           (lhs.memoryTypeBits == rhs.memoryTypeBits);
  }
  
  bool operator!=(VkAndroidHardwareBufferPropertiesANDROID const &lhs,
                  VkAndroidHardwareBufferPropertiesANDROID const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkMemoryGetAndroidHardwareBufferInfoANDROID const &lhs,
                  VkMemoryGetAndroidHardwareBufferInfoANDROID const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.memory == rhs.memory);
  }
  
  bool operator!=(VkMemoryGetAndroidHardwareBufferInfoANDROID const &lhs,
                  VkMemoryGetAndroidHardwareBufferInfoANDROID const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkAndroidHardwareBufferFormatPropertiesANDROID const &lhs,
                  VkAndroidHardwareBufferFormatPropertiesANDROID const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.format == rhs.format) &&
           (lhs.externalFormat == rhs.externalFormat) &&
           (lhs.formatFeatures == rhs.formatFeatures) &&
           (lhs.samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents) &&
           (lhs.suggestedYcbcrModel == rhs.suggestedYcbcrModel) &&
           (lhs.suggestedYcbcrRange == rhs.suggestedYcbcrRange) &&
           (lhs.suggestedXChromaOffset == rhs.suggestedXChromaOffset) &&
           (lhs.suggestedYChromaOffset == rhs.suggestedYChromaOffset);
  }
  
  bool operator!=(VkAndroidHardwareBufferFormatPropertiesANDROID const &lhs,
                  VkAndroidHardwareBufferFormatPropertiesANDROID const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  bool operator==(VkCommandBufferInheritanceConditionalRenderingInfoEXT const &lhs,
                  VkCommandBufferInheritanceConditionalRenderingInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.conditionalRenderingEnable == rhs.conditionalRenderingEnable);
  }
  
  bool operator!=(VkCommandBufferInheritanceConditionalRenderingInfoEXT const &lhs,
                  VkCommandBufferInheritanceConditionalRenderingInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  bool operator==(VkExternalFormatANDROID const &lhs,
                  VkExternalFormatANDROID const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.externalFormat == rhs.externalFormat);
  }
  
  bool operator!=(VkExternalFormatANDROID const &lhs,
                  VkExternalFormatANDROID const &rhs) noexcept {
    return !(lhs == rhs);
  }
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  bool operator==(VkPhysicalDevice8BitStorageFeaturesKHR const &lhs,
                  VkPhysicalDevice8BitStorageFeaturesKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.storageBuffer8BitAccess == rhs.storageBuffer8BitAccess) &&
           (lhs.uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess) &&
           (lhs.storagePushConstant8 == rhs.storagePushConstant8);
  }
  
  bool operator!=(VkPhysicalDevice8BitStorageFeaturesKHR const &lhs,
                  VkPhysicalDevice8BitStorageFeaturesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceConditionalRenderingFeaturesEXT const &lhs,
                  VkPhysicalDeviceConditionalRenderingFeaturesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.conditionalRendering == rhs.conditionalRendering) &&
           (lhs.inheritedConditionalRendering == rhs.inheritedConditionalRendering);
  }
  
  bool operator!=(VkPhysicalDeviceConditionalRenderingFeaturesEXT const &lhs,
                  VkPhysicalDeviceConditionalRenderingFeaturesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const &lhs,
                  VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.vulkanMemoryModel == rhs.vulkanMemoryModel) &&
           (lhs.vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope);
  }
  
  bool operator!=(VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const &lhs,
                  VkPhysicalDeviceVulkanMemoryModelFeaturesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &lhs,
                  VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics) &&
           (lhs.shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics);
  }
  
  bool operator!=(VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &lhs,
                  VkPhysicalDeviceShaderAtomicInt64FeaturesKHR const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &lhs,
                  VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor) &&
           (lhs.vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor);
  }
  
  bool operator!=(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &lhs,
                  VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkQueueFamilyCheckpointPropertiesNV const &lhs,
                  VkQueueFamilyCheckpointPropertiesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.checkpointExecutionStageMask == rhs.checkpointExecutionStageMask);
  }
  
  bool operator!=(VkQueueFamilyCheckpointPropertiesNV const &lhs,
                  VkQueueFamilyCheckpointPropertiesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCheckpointDataNV const &lhs,
                  VkCheckpointDataNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.stage == rhs.stage) &&
           (lhs.pCheckpointMarker == rhs.pCheckpointMarker);
  }
  
  bool operator!=(VkCheckpointDataNV const &lhs,
                  VkCheckpointDataNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageViewASTCDecodeModeEXT const &lhs,
                  VkImageViewASTCDecodeModeEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.decodeMode == rhs.decodeMode);
  }
  
  bool operator!=(VkImageViewASTCDecodeModeEXT const &lhs,
                  VkImageViewASTCDecodeModeEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceASTCDecodeFeaturesEXT const &lhs,
                  VkPhysicalDeviceASTCDecodeFeaturesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.decodeModeSharedExponent == rhs.decodeModeSharedExponent);
  }
  
  bool operator!=(VkPhysicalDeviceASTCDecodeFeaturesEXT const &lhs,
                  VkPhysicalDeviceASTCDecodeFeaturesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceTransformFeedbackFeaturesEXT const &lhs,
                  VkPhysicalDeviceTransformFeedbackFeaturesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.transformFeedback == rhs.transformFeedback) &&
           (lhs.geometryStreams == rhs.geometryStreams);
  }
  
  bool operator!=(VkPhysicalDeviceTransformFeedbackFeaturesEXT const &lhs,
                  VkPhysicalDeviceTransformFeedbackFeaturesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceTransformFeedbackPropertiesEXT const &lhs,
                  VkPhysicalDeviceTransformFeedbackPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams) &&
           (lhs.maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers) &&
           (lhs.maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize) &&
           (lhs.maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize) &&
           (lhs.maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize) &&
           (lhs.maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride) &&
           (lhs.transformFeedbackQueries == rhs.transformFeedbackQueries) &&
           (lhs.transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles) &&
           (lhs.transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect) &&
           (lhs.transformFeedbackDraw == rhs.transformFeedbackDraw);
  }
  
  bool operator!=(VkPhysicalDeviceTransformFeedbackPropertiesEXT const &lhs,
                  VkPhysicalDeviceTransformFeedbackPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineRasterizationStateStreamCreateInfoEXT const &lhs,
                  VkPipelineRasterizationStateStreamCreateInfoEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.rasterizationStream == rhs.rasterizationStream);
  }
  
  bool operator!=(VkPipelineRasterizationStateStreamCreateInfoEXT const &lhs,
                  VkPipelineRasterizationStateStreamCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &lhs,
                  VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.representativeFragmentTest == rhs.representativeFragmentTest);
  }
  
  bool operator!=(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &lhs,
                  VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &lhs,
                  VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.representativeFragmentTestEnable == rhs.representativeFragmentTestEnable);
  }
  
  bool operator!=(VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &lhs,
                  VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceExclusiveScissorFeaturesNV const &lhs,
                  VkPhysicalDeviceExclusiveScissorFeaturesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.exclusiveScissor == rhs.exclusiveScissor);
  }
  
  bool operator!=(VkPhysicalDeviceExclusiveScissorFeaturesNV const &lhs,
                  VkPhysicalDeviceExclusiveScissorFeaturesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineViewportExclusiveScissorStateCreateInfoNV const &lhs,
                  VkPipelineViewportExclusiveScissorStateCreateInfoNV const &rhs) noexcept {
    if(lhs.exclusiveScissorCount != rhs.exclusiveScissorCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.exclusiveScissorCount; ++i) {
      if(lhs.pExclusiveScissors[i] != rhs.pExclusiveScissors[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkPipelineViewportExclusiveScissorStateCreateInfoNV const &lhs,
                  VkPipelineViewportExclusiveScissorStateCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceCornerSampledImageFeaturesNV const &lhs,
                  VkPhysicalDeviceCornerSampledImageFeaturesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.cornerSampledImage == rhs.cornerSampledImage);
  }
  
  bool operator!=(VkPhysicalDeviceCornerSampledImageFeaturesNV const &lhs,
                  VkPhysicalDeviceCornerSampledImageFeaturesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &lhs,
                  VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads) &&
           (lhs.computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear);
  }
  
  bool operator!=(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &lhs,
                  VkPhysicalDeviceComputeShaderDerivativesFeaturesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &lhs,
                  VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.fragmentShaderBarycentric == rhs.fragmentShaderBarycentric);
  }
  
  bool operator!=(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &lhs,
                  VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceShaderImageFootprintFeaturesNV const &lhs,
                  VkPhysicalDeviceShaderImageFootprintFeaturesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.imageFootprint == rhs.imageFootprint);
  }
  
  bool operator!=(VkPhysicalDeviceShaderImageFootprintFeaturesNV const &lhs,
                  VkPhysicalDeviceShaderImageFootprintFeaturesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkShadingRatePaletteNV const &lhs,
                  VkShadingRatePaletteNV const &rhs) noexcept {
    if(lhs.shadingRatePaletteEntryCount != rhs.shadingRatePaletteEntryCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.shadingRatePaletteEntryCount; ++i) {
      if(lhs.pShadingRatePaletteEntries[i] != rhs.pShadingRatePaletteEntries[i])
        return false;
    }
  
    return true;
  }
  
  bool operator!=(VkShadingRatePaletteNV const &lhs,
                  VkShadingRatePaletteNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineViewportShadingRateImageStateCreateInfoNV const &lhs,
                  VkPipelineViewportShadingRateImageStateCreateInfoNV const &rhs) noexcept {
    if(lhs.viewportCount != rhs.viewportCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.viewportCount; ++i) {
      if(lhs.pShadingRatePalettes[i] != rhs.pShadingRatePalettes[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.shadingRateImageEnable == rhs.shadingRateImageEnable);
  }
  
  bool operator!=(VkPipelineViewportShadingRateImageStateCreateInfoNV const &lhs,
                  VkPipelineViewportShadingRateImageStateCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceShadingRateImageFeaturesNV const &lhs,
                  VkPhysicalDeviceShadingRateImageFeaturesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.shadingRateImage == rhs.shadingRateImage) &&
           (lhs.shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder);
  }
  
  bool operator!=(VkPhysicalDeviceShadingRateImageFeaturesNV const &lhs,
                  VkPhysicalDeviceShadingRateImageFeaturesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceShadingRateImagePropertiesNV const &lhs,
                  VkPhysicalDeviceShadingRateImagePropertiesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.shadingRateTexelSize == rhs.shadingRateTexelSize) &&
           (lhs.shadingRatePaletteSize == rhs.shadingRatePaletteSize) &&
           (lhs.shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples);
  }
  
  bool operator!=(VkPhysicalDeviceShadingRateImagePropertiesNV const &lhs,
                  VkPhysicalDeviceShadingRateImagePropertiesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCoarseSampleLocationNV const &lhs,
                  VkCoarseSampleLocationNV const &rhs) noexcept {
    return (lhs.pixelX == rhs.pixelX) &&
           (lhs.pixelY == rhs.pixelY) &&
           (lhs.sample == rhs.sample);
  }
  
  bool operator!=(VkCoarseSampleLocationNV const &lhs,
                  VkCoarseSampleLocationNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkCoarseSampleOrderCustomNV const &lhs,
                  VkCoarseSampleOrderCustomNV const &rhs) noexcept {
    if(lhs.sampleLocationCount != rhs.sampleLocationCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.sampleLocationCount; ++i) {
      if(lhs.pSampleLocations[i] != rhs.pSampleLocations[i])
        return false;
    }
  
    return (lhs.shadingRate == rhs.shadingRate) &&
           (lhs.sampleCount == rhs.sampleCount);
  }
  
  bool operator!=(VkCoarseSampleOrderCustomNV const &lhs,
                  VkCoarseSampleOrderCustomNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &lhs,
                  VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &rhs) noexcept {
    if(lhs.customSampleOrderCount != rhs.customSampleOrderCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.customSampleOrderCount; ++i) {
      if(lhs.pCustomSampleOrders[i] != rhs.pCustomSampleOrders[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.sampleOrderType == rhs.sampleOrderType);
  }
  
  bool operator!=(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &lhs,
                  VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceMeshShaderFeaturesNV const &lhs,
                  VkPhysicalDeviceMeshShaderFeaturesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.taskShader == rhs.taskShader) &&
           (lhs.meshShader == rhs.meshShader);
  }
  
  bool operator!=(VkPhysicalDeviceMeshShaderFeaturesNV const &lhs,
                  VkPhysicalDeviceMeshShaderFeaturesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceMeshShaderPropertiesNV const &lhs,
                  VkPhysicalDeviceMeshShaderPropertiesNV const &rhs) noexcept {
    for(uint32_t i = 0; i < 3; ++i) {
      if(lhs.maxTaskWorkGroupSize[i] != rhs.maxTaskWorkGroupSize[i])
        return false;
    }
  
    for(uint32_t i = 0; i < 3; ++i) {
      if(lhs.maxMeshWorkGroupSize[i] != rhs.maxMeshWorkGroupSize[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount) &&
           (lhs.maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations) &&
           (lhs.maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize) &&
           (lhs.maxTaskOutputCount == rhs.maxTaskOutputCount) &&
           (lhs.maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations) &&
           (lhs.maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize) &&
           (lhs.maxMeshOutputVertices == rhs.maxMeshOutputVertices) &&
           (lhs.maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives) &&
           (lhs.maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount) &&
           (lhs.meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity) &&
           (lhs.meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity);
  }
  
  bool operator!=(VkPhysicalDeviceMeshShaderPropertiesNV const &lhs,
                  VkPhysicalDeviceMeshShaderPropertiesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDrawMeshTasksIndirectCommandNV const &lhs,
                  VkDrawMeshTasksIndirectCommandNV const &rhs) noexcept {
    return (lhs.taskCount == rhs.taskCount) &&
           (lhs.firstTask == rhs.firstTask);
  }
  
  bool operator!=(VkDrawMeshTasksIndirectCommandNV const &lhs,
                  VkDrawMeshTasksIndirectCommandNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRayTracingShaderGroupCreateInfoNV const &lhs,
                  VkRayTracingShaderGroupCreateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.type == rhs.type) &&
           (lhs.generalShader == rhs.generalShader) &&
           (lhs.closestHitShader == rhs.closestHitShader) &&
           (lhs.anyHitShader == rhs.anyHitShader) &&
           (lhs.intersectionShader == rhs.intersectionShader);
  }
  
  bool operator!=(VkRayTracingShaderGroupCreateInfoNV const &lhs,
                  VkRayTracingShaderGroupCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkRayTracingPipelineCreateInfoNV const &lhs,
                  VkRayTracingPipelineCreateInfoNV const &rhs) noexcept {
    if(lhs.stageCount != rhs.stageCount)
      return false;
  
    if(lhs.groupCount != rhs.groupCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.stageCount; ++i) {
      if(lhs.pStages[i] != rhs.pStages[i])
        return false;
    }
  
    for(uint32_t i = 0; i < lhs.groupCount; ++i) {
      if(lhs.pGroups[i] != rhs.pGroups[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.flags == rhs.flags) &&
           (lhs.maxRecursionDepth == rhs.maxRecursionDepth) &&
           (lhs.layout == rhs.layout) &&
           (lhs.basePipelineHandle == rhs.basePipelineHandle) &&
           (lhs.basePipelineIndex == rhs.basePipelineIndex);
  }
  
  bool operator!=(VkRayTracingPipelineCreateInfoNV const &lhs,
                  VkRayTracingPipelineCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkGeometryTrianglesNV const &lhs,
                  VkGeometryTrianglesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.vertexData == rhs.vertexData) &&
           (lhs.vertexOffset == rhs.vertexOffset) &&
           (lhs.vertexCount == rhs.vertexCount) &&
           (lhs.vertexStride == rhs.vertexStride) &&
           (lhs.vertexFormat == rhs.vertexFormat) &&
           (lhs.indexData == rhs.indexData) &&
           (lhs.indexOffset == rhs.indexOffset) &&
           (lhs.indexCount == rhs.indexCount) &&
           (lhs.indexType == rhs.indexType) &&
           (lhs.transformData == rhs.transformData) &&
           (lhs.transformOffset == rhs.transformOffset);
  }
  
  bool operator!=(VkGeometryTrianglesNV const &lhs,
                  VkGeometryTrianglesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkGeometryAABBNV const &lhs,
                  VkGeometryAABBNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.aabbData == rhs.aabbData) &&
           (lhs.numAABBs == rhs.numAABBs) &&
           (lhs.stride == rhs.stride) &&
           (lhs.offset == rhs.offset);
  }
  
  bool operator!=(VkGeometryAABBNV const &lhs,
                  VkGeometryAABBNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkGeometryDataNV const &lhs,
                  VkGeometryDataNV const &rhs) noexcept {
    return (lhs.triangles == rhs.triangles) &&
           (lhs.aabbs == rhs.aabbs);
  }
  
  bool operator!=(VkGeometryDataNV const &lhs,
                  VkGeometryDataNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkGeometryNV const &lhs,
                  VkGeometryNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.geometryType == rhs.geometryType) &&
           (lhs.geometry == rhs.geometry) &&
           (lhs.flags == rhs.flags);
  }
  
  bool operator!=(VkGeometryNV const &lhs,
                  VkGeometryNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAccelerationStructureInfoNV const &lhs,
                  VkAccelerationStructureInfoNV const &rhs) noexcept {
    if(lhs.geometryCount != rhs.geometryCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.geometryCount; ++i) {
      if(lhs.pGeometries[i] != rhs.pGeometries[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.type == rhs.type) &&
           (lhs.flags == rhs.flags) &&
           (lhs.instanceCount == rhs.instanceCount);
  }
  
  bool operator!=(VkAccelerationStructureInfoNV const &lhs,
                  VkAccelerationStructureInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAccelerationStructureCreateInfoNV const &lhs,
                  VkAccelerationStructureCreateInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.compactedSize == rhs.compactedSize) &&
           (lhs.info == rhs.info);
  }
  
  bool operator!=(VkAccelerationStructureCreateInfoNV const &lhs,
                  VkAccelerationStructureCreateInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkBindAccelerationStructureMemoryInfoNV const &lhs,
                  VkBindAccelerationStructureMemoryInfoNV const &rhs) noexcept {
    if(lhs.deviceIndexCount != rhs.deviceIndexCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.deviceIndexCount; ++i) {
      if(lhs.pDeviceIndices[i] != rhs.pDeviceIndices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.accelerationStructure == rhs.accelerationStructure) &&
           (lhs.memory == rhs.memory) &&
           (lhs.memoryOffset == rhs.memoryOffset);
  }
  
  bool operator!=(VkBindAccelerationStructureMemoryInfoNV const &lhs,
                  VkBindAccelerationStructureMemoryInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkWriteDescriptorSetAccelerationStructureNV const &lhs,
                  VkWriteDescriptorSetAccelerationStructureNV const &rhs) noexcept {
    if(lhs.accelerationStructureCount != rhs.accelerationStructureCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.accelerationStructureCount; ++i) {
      if(lhs.pAccelerationStructures[i] != rhs.pAccelerationStructures[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkWriteDescriptorSetAccelerationStructureNV const &lhs,
                  VkWriteDescriptorSetAccelerationStructureNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkAccelerationStructureMemoryRequirementsInfoNV const &lhs,
                  VkAccelerationStructureMemoryRequirementsInfoNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.type == rhs.type) &&
           (lhs.accelerationStructure == rhs.accelerationStructure);
  }
  
  bool operator!=(VkAccelerationStructureMemoryRequirementsInfoNV const &lhs,
                  VkAccelerationStructureMemoryRequirementsInfoNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceRayTracingPropertiesNV const &lhs,
                  VkPhysicalDeviceRayTracingPropertiesNV const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.shaderGroupHandleSize == rhs.shaderGroupHandleSize) &&
           (lhs.maxRecursionDepth == rhs.maxRecursionDepth) &&
           (lhs.maxShaderGroupStride == rhs.maxShaderGroupStride) &&
           (lhs.shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment) &&
           (lhs.maxGeometryCount == rhs.maxGeometryCount) &&
           (lhs.maxInstanceCount == rhs.maxInstanceCount) &&
           (lhs.maxTriangleCount == rhs.maxTriangleCount) &&
           (lhs.maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures);
  }
  
  bool operator!=(VkPhysicalDeviceRayTracingPropertiesNV const &lhs,
                  VkPhysicalDeviceRayTracingPropertiesNV const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDrmFormatModifierPropertiesListEXT const &lhs,
                  VkDrmFormatModifierPropertiesListEXT const &rhs) noexcept {
    if(lhs.drmFormatModifierCount != rhs.drmFormatModifierCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.drmFormatModifierCount; ++i) {
      if(lhs.pDrmFormatModifierProperties[i] != rhs.pDrmFormatModifierProperties[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkDrmFormatModifierPropertiesListEXT const &lhs,
                  VkDrmFormatModifierPropertiesListEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDrmFormatModifierPropertiesEXT const &lhs,
                  VkDrmFormatModifierPropertiesEXT const &rhs) noexcept {
    return (lhs.drmFormatModifier == rhs.drmFormatModifier) &&
           (lhs.drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount) &&
           (lhs.drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures);
  }
  
  bool operator!=(VkDrmFormatModifierPropertiesEXT const &lhs,
                  VkDrmFormatModifierPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &lhs,
                  VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &rhs) noexcept {
    if(lhs.queueFamilyIndexCount != rhs.queueFamilyIndexCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.queueFamilyIndexCount; ++i) {
      if(lhs.pQueueFamilyIndices[i] != rhs.pQueueFamilyIndices[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.drmFormatModifier == rhs.drmFormatModifier) &&
           (lhs.sharingMode == rhs.sharingMode);
  }
  
  bool operator!=(VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &lhs,
                  VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageDrmFormatModifierListCreateInfoEXT const &lhs,
                  VkImageDrmFormatModifierListCreateInfoEXT const &rhs) noexcept {
    if(lhs.drmFormatModifierCount != rhs.drmFormatModifierCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.drmFormatModifierCount; ++i) {
      if(lhs.pDrmFormatModifiers[i] != rhs.pDrmFormatModifiers[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType);
  }
  
  bool operator!=(VkImageDrmFormatModifierListCreateInfoEXT const &lhs,
                  VkImageDrmFormatModifierListCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageDrmFormatModifierExplicitCreateInfoEXT const &lhs,
                  VkImageDrmFormatModifierExplicitCreateInfoEXT const &rhs) noexcept {
    if(lhs.drmFormatModifierPlaneCount != rhs.drmFormatModifierPlaneCount)
      return false;
  
    for(uint32_t i = 0; i < lhs.drmFormatModifierPlaneCount; ++i) {
      if(lhs.pPlaneLayouts[i] != rhs.pPlaneLayouts[i])
        return false;
    }
  
    return (lhs.sType == rhs.sType) &&
           (lhs.drmFormatModifier == rhs.drmFormatModifier);
  }
  
  bool operator!=(VkImageDrmFormatModifierExplicitCreateInfoEXT const &lhs,
                  VkImageDrmFormatModifierExplicitCreateInfoEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkImageDrmFormatModifierPropertiesEXT const &lhs,
                  VkImageDrmFormatModifierPropertiesEXT const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.drmFormatModifier == rhs.drmFormatModifier);
  }
  
  bool operator!=(VkImageDrmFormatModifierPropertiesEXT const &lhs,
                  VkImageDrmFormatModifierPropertiesEXT const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  bool operator==(VkDeviceMemoryOverallocationCreateInfoAMD const &lhs,
                  VkDeviceMemoryOverallocationCreateInfoAMD const &rhs) noexcept {
    return (lhs.sType == rhs.sType) &&
           (lhs.overallocationBehavior == rhs.overallocationBehavior);
  }
  
  bool operator!=(VkDeviceMemoryOverallocationCreateInfoAMD const &lhs,
                  VkDeviceMemoryOverallocationCreateInfoAMD const &rhs) noexcept {
    return !(lhs == rhs);
  }
  
  #endif // VK_EQUALITY_CHECK_CONFIG_MAIN
  
  #endif // VK_EQUALITY_CHECK_V91_HPP
  