// Copyright (C) 2018 The Android Open Source Project
// Copyright (C) 2018 Google Inc.
//
// 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.

// Autogenerated module goldfish_vk_testing
//
// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
// cereal -o ../../device/generic/vulkan-cereal/host/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
//
// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
// $CEREAL_OUTPUT_DIR
//
#pragma once
#include <string.h>
#include <vulkan/vulkan.h>

#include <functional>

#include "goldfish_vk_private_defs.h"
#include "vk_android_native_buffer.h"
#include "vulkan_gfxstream.h"
using OnFailCompareFunc = std::function<void(const char*)>;

namespace gfxstream {
namespace vk {

#ifdef VK_VERSION_1_0
void checkEqual_VkExtent2D(const VkExtent2D* a, const VkExtent2D* b, OnFailCompareFunc onFail);

void checkEqual_VkExtent3D(const VkExtent3D* a, const VkExtent3D* b, OnFailCompareFunc onFail);

void checkEqual_VkOffset2D(const VkOffset2D* a, const VkOffset2D* b, OnFailCompareFunc onFail);

void checkEqual_VkOffset3D(const VkOffset3D* a, const VkOffset3D* b, OnFailCompareFunc onFail);

void checkEqual_VkRect2D(const VkRect2D* a, const VkRect2D* b, OnFailCompareFunc onFail);

void checkEqual_VkBaseInStructure(const VkBaseInStructure* a, const VkBaseInStructure* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkBaseOutStructure(const VkBaseOutStructure* a, const VkBaseOutStructure* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* a,
                                      const VkBufferMemoryBarrier* b, OnFailCompareFunc onFail);

void checkEqual_VkDispatchIndirectCommand(const VkDispatchIndirectCommand* a,
                                          const VkDispatchIndirectCommand* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkDrawIndexedIndirectCommand(const VkDrawIndexedIndirectCommand* a,
                                             const VkDrawIndexedIndirectCommand* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkDrawIndirectCommand(const VkDrawIndirectCommand* a,
                                      const VkDrawIndirectCommand* b, OnFailCompareFunc onFail);

void checkEqual_VkImageSubresourceRange(const VkImageSubresourceRange* a,
                                        const VkImageSubresourceRange* b, OnFailCompareFunc onFail);

void checkEqual_VkImageMemoryBarrier(const VkImageMemoryBarrier* a, const VkImageMemoryBarrier* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkMemoryBarrier(const VkMemoryBarrier* a, const VkMemoryBarrier* b,
                                OnFailCompareFunc onFail);

void checkEqual_VkPipelineCacheHeaderVersionOne(const VkPipelineCacheHeaderVersionOne* a,
                                                const VkPipelineCacheHeaderVersionOne* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkAllocationCallbacks(const VkAllocationCallbacks* a,
                                      const VkAllocationCallbacks* b, OnFailCompareFunc onFail);

void checkEqual_VkApplicationInfo(const VkApplicationInfo* a, const VkApplicationInfo* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkFormatProperties(const VkFormatProperties* a, const VkFormatProperties* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkImageFormatProperties(const VkImageFormatProperties* a,
                                        const VkImageFormatProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkInstanceCreateInfo(const VkInstanceCreateInfo* a, const VkInstanceCreateInfo* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkMemoryHeap(const VkMemoryHeap* a, const VkMemoryHeap* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkMemoryType(const VkMemoryType* a, const VkMemoryType* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFeatures(const VkPhysicalDeviceFeatures* a,
                                         const VkPhysicalDeviceFeatures* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceLimits(const VkPhysicalDeviceLimits* a,
                                       const VkPhysicalDeviceLimits* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMemoryProperties(const VkPhysicalDeviceMemoryProperties* a,
                                                 const VkPhysicalDeviceMemoryProperties* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSparseProperties(const VkPhysicalDeviceSparseProperties* a,
                                                 const VkPhysicalDeviceSparseProperties* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceProperties(const VkPhysicalDeviceProperties* a,
                                           const VkPhysicalDeviceProperties* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkQueueFamilyProperties(const VkQueueFamilyProperties* a,
                                        const VkQueueFamilyProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* a,
                                        const VkDeviceQueueCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceCreateInfo(const VkDeviceCreateInfo* a, const VkDeviceCreateInfo* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkExtensionProperties(const VkExtensionProperties* a,
                                      const VkExtensionProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkLayerProperties(const VkLayerProperties* a, const VkLayerProperties* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkSubmitInfo(const VkSubmitInfo* a, const VkSubmitInfo* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkMappedMemoryRange(const VkMappedMemoryRange* a, const VkMappedMemoryRange* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* a, const VkMemoryAllocateInfo* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkMemoryRequirements(const VkMemoryRequirements* a, const VkMemoryRequirements* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkSparseMemoryBind(const VkSparseMemoryBind* a, const VkSparseMemoryBind* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* a,
                                             const VkSparseBufferMemoryBindInfo* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkSparseImageOpaqueMemoryBindInfo(const VkSparseImageOpaqueMemoryBindInfo* a,
                                                  const VkSparseImageOpaqueMemoryBindInfo* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkImageSubresource(const VkImageSubresource* a, const VkImageSubresource* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkSparseImageMemoryBind(const VkSparseImageMemoryBind* a,
                                        const VkSparseImageMemoryBind* b, OnFailCompareFunc onFail);

void checkEqual_VkSparseImageMemoryBindInfo(const VkSparseImageMemoryBindInfo* a,
                                            const VkSparseImageMemoryBindInfo* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkBindSparseInfo(const VkBindSparseInfo* a, const VkBindSparseInfo* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkSparseImageFormatProperties(const VkSparseImageFormatProperties* a,
                                              const VkSparseImageFormatProperties* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkSparseImageMemoryRequirements(const VkSparseImageMemoryRequirements* a,
                                                const VkSparseImageMemoryRequirements* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkFenceCreateInfo(const VkFenceCreateInfo* a, const VkFenceCreateInfo* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* a,
                                      const VkSemaphoreCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkEventCreateInfo(const VkEventCreateInfo* a, const VkEventCreateInfo* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* a,
                                      const VkQueryPoolCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkBufferCreateInfo(const VkBufferCreateInfo* a, const VkBufferCreateInfo* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* a,
                                       const VkBufferViewCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkImageCreateInfo(const VkImageCreateInfo* a, const VkImageCreateInfo* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkSubresourceLayout(const VkSubresourceLayout* a, const VkSubresourceLayout* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkComponentMapping(const VkComponentMapping* a, const VkComponentMapping* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkImageViewCreateInfo(const VkImageViewCreateInfo* a,
                                      const VkImageViewCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* a,
                                         const VkShaderModuleCreateInfo* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* a,
                                          const VkPipelineCacheCreateInfo* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkSpecializationMapEntry(const VkSpecializationMapEntry* a,
                                         const VkSpecializationMapEntry* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkSpecializationInfo(const VkSpecializationInfo* a, const VkSpecializationInfo* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* a,
                                                const VkPipelineShaderStageCreateInfo* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* a,
                                            const VkComputePipelineCreateInfo* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkVertexInputBindingDescription(const VkVertexInputBindingDescription* a,
                                                const VkVertexInputBindingDescription* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVertexInputAttributeDescription(const VkVertexInputAttributeDescription* a,
                                                  const VkVertexInputAttributeDescription* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* a,
                                                     const VkPipelineVertexInputStateCreateInfo* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkPipelineInputAssemblyStateCreateInfo(
    const VkPipelineInputAssemblyStateCreateInfo* a,
    const VkPipelineInputAssemblyStateCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineTessellationStateCreateInfo(
    const VkPipelineTessellationStateCreateInfo* a, const VkPipelineTessellationStateCreateInfo* b,
    OnFailCompareFunc onFail);

void checkEqual_VkViewport(const VkViewport* a, const VkViewport* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* a,
                                                  const VkPipelineViewportStateCreateInfo* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkPipelineRasterizationStateCreateInfo(
    const VkPipelineRasterizationStateCreateInfo* a,
    const VkPipelineRasterizationStateCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* a,
                                                     const VkPipelineMultisampleStateCreateInfo* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkStencilOpState(const VkStencilOpState* a, const VkStencilOpState* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkPipelineDepthStencilStateCreateInfo(
    const VkPipelineDepthStencilStateCreateInfo* a, const VkPipelineDepthStencilStateCreateInfo* b,
    OnFailCompareFunc onFail);

void checkEqual_VkPipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState* a,
                                                    const VkPipelineColorBlendAttachmentState* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* a,
                                                    const VkPipelineColorBlendStateCreateInfo* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* a,
                                                 const VkPipelineDynamicStateCreateInfo* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* a,
                                             const VkGraphicsPipelineCreateInfo* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkPushConstantRange(const VkPushConstantRange* a, const VkPushConstantRange* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* a,
                                           const VkPipelineLayoutCreateInfo* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkSamplerCreateInfo(const VkSamplerCreateInfo* a, const VkSamplerCreateInfo* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkCopyDescriptorSet(const VkCopyDescriptorSet* a, const VkCopyDescriptorSet* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkDescriptorBufferInfo(const VkDescriptorBufferInfo* a,
                                       const VkDescriptorBufferInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorImageInfo(const VkDescriptorImageInfo* a,
                                      const VkDescriptorImageInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorPoolSize(const VkDescriptorPoolSize* a, const VkDescriptorPoolSize* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* a,
                                           const VkDescriptorPoolCreateInfo* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* a,
                                            const VkDescriptorSetAllocateInfo* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* a,
                                             const VkDescriptorSetLayoutBinding* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* a,
                                                const VkDescriptorSetLayoutCreateInfo* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkWriteDescriptorSet(const VkWriteDescriptorSet* a, const VkWriteDescriptorSet* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkAttachmentDescription(const VkAttachmentDescription* a,
                                        const VkAttachmentDescription* b, OnFailCompareFunc onFail);

void checkEqual_VkAttachmentReference(const VkAttachmentReference* a,
                                      const VkAttachmentReference* b, OnFailCompareFunc onFail);

void checkEqual_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* a,
                                        const VkFramebufferCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkSubpassDescription(const VkSubpassDescription* a, const VkSubpassDescription* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkSubpassDependency(const VkSubpassDependency* a, const VkSubpassDependency* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* a,
                                       const VkRenderPassCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* a,
                                        const VkCommandPoolCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* a,
                                            const VkCommandBufferAllocateInfo* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* a,
                                               const VkCommandBufferInheritanceInfo* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* a,
                                         const VkCommandBufferBeginInfo* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkBufferCopy(const VkBufferCopy* a, const VkBufferCopy* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkImageSubresourceLayers(const VkImageSubresourceLayers* a,
                                         const VkImageSubresourceLayers* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkBufferImageCopy(const VkBufferImageCopy* a, const VkBufferImageCopy* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkClearColorValue(const VkClearColorValue* a, const VkClearColorValue* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkClearDepthStencilValue(const VkClearDepthStencilValue* a,
                                         const VkClearDepthStencilValue* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkClearValue(const VkClearValue* a, const VkClearValue* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkClearAttachment(const VkClearAttachment* a, const VkClearAttachment* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkClearRect(const VkClearRect* a, const VkClearRect* b, OnFailCompareFunc onFail);

void checkEqual_VkImageBlit(const VkImageBlit* a, const VkImageBlit* b, OnFailCompareFunc onFail);

void checkEqual_VkImageCopy(const VkImageCopy* a, const VkImageCopy* b, OnFailCompareFunc onFail);

void checkEqual_VkImageResolve(const VkImageResolve* a, const VkImageResolve* b,
                               OnFailCompareFunc onFail);

void checkEqual_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* a,
                                      const VkRenderPassBeginInfo* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_VERSION_1_1
void checkEqual_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* a,
                                                   const VkPhysicalDeviceSubgroupProperties* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* a,
                                       const VkBindBufferMemoryInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* a,
                                      const VkBindImageMemoryInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* a,
                                                     const VkPhysicalDevice16BitStorageFeatures* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* a,
                                              const VkMemoryDedicatedRequirements* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* a,
                                              const VkMemoryDedicatedAllocateInfo* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* a,
                                          const VkMemoryAllocateFlagsInfo* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* a,
                                                 const VkDeviceGroupRenderPassBeginInfo* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* a,
                                                    const VkDeviceGroupCommandBufferBeginInfo* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* a,
                                        const VkDeviceGroupSubmitInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* a,
                                            const VkDeviceGroupBindSparseInfo* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* a,
                                                  const VkBindBufferMemoryDeviceGroupInfo* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* a,
                                                 const VkBindImageMemoryDeviceGroupInfo* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* a,
                                                const VkPhysicalDeviceGroupProperties* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* a,
                                              const VkDeviceGroupDeviceCreateInfo* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* a,
                                                const VkBufferMemoryRequirementsInfo2* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* a,
                                               const VkImageMemoryRequirementsInfo2* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* a,
                                                     const VkImageSparseMemoryRequirementsInfo2* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkMemoryRequirements2(const VkMemoryRequirements2* a,
                                      const VkMemoryRequirements2* b, OnFailCompareFunc onFail);

void checkEqual_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* a,
                                                 const VkSparseImageMemoryRequirements2* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* a,
                                          const VkPhysicalDeviceFeatures2* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* a,
                                            const VkPhysicalDeviceProperties2* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkFormatProperties2(const VkFormatProperties2* a, const VkFormatProperties2* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkImageFormatProperties2(const VkImageFormatProperties2* a,
                                         const VkImageFormatProperties2* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* a,
                                                 const VkPhysicalDeviceImageFormatInfo2* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* a,
                                         const VkQueueFamilyProperties2* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* a,
                                                  const VkPhysicalDeviceMemoryProperties2* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* a,
                                               const VkSparseImageFormatProperties2* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSparseImageFormatInfo2(
    const VkPhysicalDeviceSparseImageFormatInfo2* a,
    const VkPhysicalDeviceSparseImageFormatInfo2* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePointClippingProperties(
    const VkPhysicalDevicePointClippingProperties* a,
    const VkPhysicalDevicePointClippingProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkInputAttachmentAspectReference(const VkInputAttachmentAspectReference* a,
                                                 const VkInputAttachmentAspectReference* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkRenderPassInputAttachmentAspectCreateInfo(
    const VkRenderPassInputAttachmentAspectCreateInfo* a,
    const VkRenderPassInputAttachmentAspectCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* a,
                                           const VkImageViewUsageCreateInfo* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkPipelineTessellationDomainOriginStateCreateInfo(
    const VkPipelineTessellationDomainOriginStateCreateInfo* a,
    const VkPipelineTessellationDomainOriginStateCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* a,
                                                const VkRenderPassMultiviewCreateInfo* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* a,
                                                  const VkPhysicalDeviceMultiviewFeatures* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* a,
                                                    const VkPhysicalDeviceMultiviewProperties* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceVariablePointersFeatures(
    const VkPhysicalDeviceVariablePointersFeatures* a,
    const VkPhysicalDeviceVariablePointersFeatures* b, OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceVariablePointersFeatures,
                      checkEqual_VkPhysicalDeviceVariablePointerFeatures)

void checkEqual_VkPhysicalDeviceProtectedMemoryFeatures(
    const VkPhysicalDeviceProtectedMemoryFeatures* a,
    const VkPhysicalDeviceProtectedMemoryFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceProtectedMemoryProperties(
    const VkPhysicalDeviceProtectedMemoryProperties* a,
    const VkPhysicalDeviceProtectedMemoryProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* a, const VkDeviceQueueInfo2* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* a,
                                      const VkProtectedSubmitInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* a,
                                                   const VkSamplerYcbcrConversionCreateInfo* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* a,
                                             const VkSamplerYcbcrConversionInfo* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* a,
                                           const VkBindImagePlaneMemoryInfo* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* a,
                                                   const VkImagePlaneMemoryRequirementsInfo* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSamplerYcbcrConversionFeatures(
    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* a,
    const VkPhysicalDeviceSamplerYcbcrConversionFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkSamplerYcbcrConversionImageFormatProperties(
    const VkSamplerYcbcrConversionImageFormatProperties* a,
    const VkSamplerYcbcrConversionImageFormatProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorUpdateTemplateEntry(const VkDescriptorUpdateTemplateEntry* a,
                                                const VkDescriptorUpdateTemplateEntry* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* a,
                                                     const VkDescriptorUpdateTemplateCreateInfo* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkExternalMemoryProperties(const VkExternalMemoryProperties* a,
                                           const VkExternalMemoryProperties* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceExternalImageFormatInfo(
    const VkPhysicalDeviceExternalImageFormatInfo* a,
    const VkPhysicalDeviceExternalImageFormatInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* a,
                                                const VkExternalImageFormatProperties* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* a,
                                                   const VkPhysicalDeviceExternalBufferInfo* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkExternalBufferProperties(const VkExternalBufferProperties* a,
                                           const VkExternalBufferProperties* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* a,
                                             const VkPhysicalDeviceIDProperties* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* a,
                                                const VkExternalMemoryImageCreateInfo* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* a,
                                                 const VkExternalMemoryBufferCreateInfo* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* a,
                                           const VkExportMemoryAllocateInfo* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* a,
                                                  const VkPhysicalDeviceExternalFenceInfo* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkExternalFenceProperties(const VkExternalFenceProperties* a,
                                          const VkExternalFenceProperties* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* a,
                                        const VkExportFenceCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* a,
                                            const VkExportSemaphoreCreateInfo* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceExternalSemaphoreInfo(
    const VkPhysicalDeviceExternalSemaphoreInfo* a, const VkPhysicalDeviceExternalSemaphoreInfo* b,
    OnFailCompareFunc onFail);

void checkEqual_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* a,
                                              const VkExternalSemaphoreProperties* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMaintenance3Properties(
    const VkPhysicalDeviceMaintenance3Properties* a,
    const VkPhysicalDeviceMaintenance3Properties* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* a,
                                             const VkDescriptorSetLayoutSupport* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderDrawParametersFeatures(
    const VkPhysicalDeviceShaderDrawParametersFeatures* a,
    const VkPhysicalDeviceShaderDrawParametersFeatures* b, OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderDrawParametersFeatures,
                      checkEqual_VkPhysicalDeviceShaderDrawParameterFeatures)

#endif
#ifdef VK_VERSION_1_2
void checkEqual_VkPhysicalDeviceVulkan11Features(const VkPhysicalDeviceVulkan11Features* a,
                                                 const VkPhysicalDeviceVulkan11Features* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceVulkan11Properties(const VkPhysicalDeviceVulkan11Properties* a,
                                                   const VkPhysicalDeviceVulkan11Properties* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceVulkan12Features(const VkPhysicalDeviceVulkan12Features* a,
                                                 const VkPhysicalDeviceVulkan12Features* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkConformanceVersion(const VkConformanceVersion* a, const VkConformanceVersion* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceVulkan12Properties(const VkPhysicalDeviceVulkan12Properties* a,
                                                   const VkPhysicalDeviceVulkan12Properties* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkImageFormatListCreateInfo(const VkImageFormatListCreateInfo* a,
                                            const VkImageFormatListCreateInfo* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkAttachmentDescription2(const VkAttachmentDescription2* a,
                                         const VkAttachmentDescription2* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkAttachmentReference2(const VkAttachmentReference2* a,
                                       const VkAttachmentReference2* b, OnFailCompareFunc onFail);

void checkEqual_VkSubpassDescription2(const VkSubpassDescription2* a,
                                      const VkSubpassDescription2* b, OnFailCompareFunc onFail);

void checkEqual_VkSubpassDependency2(const VkSubpassDependency2* a, const VkSubpassDependency2* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkRenderPassCreateInfo2(const VkRenderPassCreateInfo2* a,
                                        const VkRenderPassCreateInfo2* b, OnFailCompareFunc onFail);

void checkEqual_VkSubpassBeginInfo(const VkSubpassBeginInfo* a, const VkSubpassBeginInfo* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkSubpassEndInfo(const VkSubpassEndInfo* a, const VkSubpassEndInfo* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevice8BitStorageFeatures(const VkPhysicalDevice8BitStorageFeatures* a,
                                                    const VkPhysicalDevice8BitStorageFeatures* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDriverProperties(const VkPhysicalDeviceDriverProperties* a,
                                                 const VkPhysicalDeviceDriverProperties* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderAtomicInt64Features(
    const VkPhysicalDeviceShaderAtomicInt64Features* a,
    const VkPhysicalDeviceShaderAtomicInt64Features* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderFloat16Int8Features(
    const VkPhysicalDeviceShaderFloat16Int8Features* a,
    const VkPhysicalDeviceShaderFloat16Int8Features* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFloatControlsProperties(
    const VkPhysicalDeviceFloatControlsProperties* a,
    const VkPhysicalDeviceFloatControlsProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetLayoutBindingFlagsCreateInfo(
    const VkDescriptorSetLayoutBindingFlagsCreateInfo* a,
    const VkDescriptorSetLayoutBindingFlagsCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDescriptorIndexingFeatures(
    const VkPhysicalDeviceDescriptorIndexingFeatures* a,
    const VkPhysicalDeviceDescriptorIndexingFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDescriptorIndexingProperties(
    const VkPhysicalDeviceDescriptorIndexingProperties* a,
    const VkPhysicalDeviceDescriptorIndexingProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetVariableDescriptorCountAllocateInfo(
    const VkDescriptorSetVariableDescriptorCountAllocateInfo* a,
    const VkDescriptorSetVariableDescriptorCountAllocateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetVariableDescriptorCountLayoutSupport(
    const VkDescriptorSetVariableDescriptorCountLayoutSupport* a,
    const VkDescriptorSetVariableDescriptorCountLayoutSupport* b, OnFailCompareFunc onFail);

void checkEqual_VkSubpassDescriptionDepthStencilResolve(
    const VkSubpassDescriptionDepthStencilResolve* a,
    const VkSubpassDescriptionDepthStencilResolve* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDepthStencilResolveProperties(
    const VkPhysicalDeviceDepthStencilResolveProperties* a,
    const VkPhysicalDeviceDepthStencilResolveProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceScalarBlockLayoutFeatures(
    const VkPhysicalDeviceScalarBlockLayoutFeatures* a,
    const VkPhysicalDeviceScalarBlockLayoutFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkImageStencilUsageCreateInfo(const VkImageStencilUsageCreateInfo* a,
                                              const VkImageStencilUsageCreateInfo* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo* a,
                                                 const VkSamplerReductionModeCreateInfo* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSamplerFilterMinmaxProperties(
    const VkPhysicalDeviceSamplerFilterMinmaxProperties* a,
    const VkPhysicalDeviceSamplerFilterMinmaxProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceVulkanMemoryModelFeatures(
    const VkPhysicalDeviceVulkanMemoryModelFeatures* a,
    const VkPhysicalDeviceVulkanMemoryModelFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceImagelessFramebufferFeatures(
    const VkPhysicalDeviceImagelessFramebufferFeatures* a,
    const VkPhysicalDeviceImagelessFramebufferFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo* a,
                                                 const VkFramebufferAttachmentImageInfo* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo* a,
                                                   const VkFramebufferAttachmentsCreateInfo* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkRenderPassAttachmentBeginInfo(const VkRenderPassAttachmentBeginInfo* a,
                                                const VkRenderPassAttachmentBeginInfo* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceUniformBufferStandardLayoutFeatures(
    const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* a,
    const VkPhysicalDeviceUniformBufferStandardLayoutFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures(
    const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* a,
    const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures(
    const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* a,
    const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkAttachmentReferenceStencilLayout(const VkAttachmentReferenceStencilLayout* a,
                                                   const VkAttachmentReferenceStencilLayout* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkAttachmentDescriptionStencilLayout(const VkAttachmentDescriptionStencilLayout* a,
                                                     const VkAttachmentDescriptionStencilLayout* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceHostQueryResetFeatures(
    const VkPhysicalDeviceHostQueryResetFeatures* a,
    const VkPhysicalDeviceHostQueryResetFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceTimelineSemaphoreFeatures(
    const VkPhysicalDeviceTimelineSemaphoreFeatures* a,
    const VkPhysicalDeviceTimelineSemaphoreFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceTimelineSemaphoreProperties(
    const VkPhysicalDeviceTimelineSemaphoreProperties* a,
    const VkPhysicalDeviceTimelineSemaphoreProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreTypeCreateInfo(const VkSemaphoreTypeCreateInfo* a,
                                          const VkSemaphoreTypeCreateInfo* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkTimelineSemaphoreSubmitInfo(const VkTimelineSemaphoreSubmitInfo* a,
                                              const VkTimelineSemaphoreSubmitInfo* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo* a, const VkSemaphoreWaitInfo* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo* a,
                                      const VkSemaphoreSignalInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceBufferDeviceAddressFeatures(
    const VkPhysicalDeviceBufferDeviceAddressFeatures* a,
    const VkPhysicalDeviceBufferDeviceAddressFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkBufferDeviceAddressInfo(const VkBufferDeviceAddressInfo* a,
                                          const VkBufferDeviceAddressInfo* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkBufferOpaqueCaptureAddressCreateInfo(
    const VkBufferOpaqueCaptureAddressCreateInfo* a,
    const VkBufferOpaqueCaptureAddressCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkMemoryOpaqueCaptureAddressAllocateInfo(
    const VkMemoryOpaqueCaptureAddressAllocateInfo* a,
    const VkMemoryOpaqueCaptureAddressAllocateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceMemoryOpaqueCaptureAddressInfo(
    const VkDeviceMemoryOpaqueCaptureAddressInfo* a,
    const VkDeviceMemoryOpaqueCaptureAddressInfo* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_surface
void checkEqual_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR* a,
                                         const VkSurfaceCapabilitiesKHR* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkSurfaceFormatKHR(const VkSurfaceFormatKHR* a, const VkSurfaceFormatKHR* b,
                                   OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_swapchain
void checkEqual_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* a,
                                         const VkSwapchainCreateInfoKHR* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkPresentInfoKHR(const VkPresentInfoKHR* a, const VkPresentInfoKHR* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* a,
                                              const VkImageSwapchainCreateInfoKHR* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* a,
                                                  const VkBindImageMemorySwapchainInfoKHR* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* a,
                                          const VkAcquireNextImageInfoKHR* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* a,
                                                    const VkDeviceGroupPresentCapabilitiesKHR* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* a,
                                            const VkDeviceGroupPresentInfoKHR* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* a,
                                                    const VkDeviceGroupSwapchainCreateInfoKHR* b,
                                                    OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_display
void checkEqual_VkDisplayModeParametersKHR(const VkDisplayModeParametersKHR* a,
                                           const VkDisplayModeParametersKHR* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* a,
                                           const VkDisplayModeCreateInfoKHR* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkDisplayModePropertiesKHR(const VkDisplayModePropertiesKHR* a,
                                           const VkDisplayModePropertiesKHR* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkDisplayPlaneCapabilitiesKHR(const VkDisplayPlaneCapabilitiesKHR* a,
                                              const VkDisplayPlaneCapabilitiesKHR* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkDisplayPlanePropertiesKHR(const VkDisplayPlanePropertiesKHR* a,
                                            const VkDisplayPlanePropertiesKHR* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* a,
                                       const VkDisplayPropertiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* a,
                                              const VkDisplaySurfaceCreateInfoKHR* b,
                                              OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_display_swapchain
void checkEqual_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* a,
                                        const VkDisplayPresentInfoKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_xlib_surface
void checkEqual_VkXlibSurfaceCreateInfoKHR(const VkXlibSurfaceCreateInfoKHR* a,
                                           const VkXlibSurfaceCreateInfoKHR* b,
                                           OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_xcb_surface
void checkEqual_VkXcbSurfaceCreateInfoKHR(const VkXcbSurfaceCreateInfoKHR* a,
                                          const VkXcbSurfaceCreateInfoKHR* b,
                                          OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_wayland_surface
void checkEqual_VkWaylandSurfaceCreateInfoKHR(const VkWaylandSurfaceCreateInfoKHR* a,
                                              const VkWaylandSurfaceCreateInfoKHR* b,
                                              OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_android_surface
void checkEqual_VkAndroidSurfaceCreateInfoKHR(const VkAndroidSurfaceCreateInfoKHR* a,
                                              const VkAndroidSurfaceCreateInfoKHR* b,
                                              OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_win32_surface
void checkEqual_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* a,
                                            const VkWin32SurfaceCreateInfoKHR* b,
                                            OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_video_queue
void checkEqual_VkVideoQueueFamilyProperties2KHR(const VkVideoQueueFamilyProperties2KHR* a,
                                                 const VkVideoQueueFamilyProperties2KHR* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoProfileKHR(const VkVideoProfileKHR* a, const VkVideoProfileKHR* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkVideoProfilesKHR(const VkVideoProfilesKHR* a, const VkVideoProfilesKHR* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* a,
                                       const VkVideoCapabilitiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR* a,
                                                   const VkPhysicalDeviceVideoFormatInfoKHR* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* a,
                                           const VkVideoFormatPropertiesKHR* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkVideoPictureResourceKHR(const VkVideoPictureResourceKHR* a,
                                          const VkVideoPictureResourceKHR* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkVideoReferenceSlotKHR(const VkVideoReferenceSlotKHR* a,
                                        const VkVideoReferenceSlotKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoGetMemoryPropertiesKHR(const VkVideoGetMemoryPropertiesKHR* a,
                                              const VkVideoGetMemoryPropertiesKHR* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkVideoBindMemoryKHR(const VkVideoBindMemoryKHR* a, const VkVideoBindMemoryKHR* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* a,
                                            const VkVideoSessionCreateInfoKHR* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkVideoSessionParametersCreateInfoKHR(
    const VkVideoSessionParametersCreateInfoKHR* a, const VkVideoSessionParametersCreateInfoKHR* b,
    OnFailCompareFunc onFail);

void checkEqual_VkVideoSessionParametersUpdateInfoKHR(
    const VkVideoSessionParametersUpdateInfoKHR* a, const VkVideoSessionParametersUpdateInfoKHR* b,
    OnFailCompareFunc onFail);

void checkEqual_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* a,
                                          const VkVideoBeginCodingInfoKHR* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkVideoEndCodingInfoKHR(const VkVideoEndCodingInfoKHR* a,
                                        const VkVideoEndCodingInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* a,
                                            const VkVideoCodingControlInfoKHR* b,
                                            OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_video_decode_queue
void checkEqual_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* a, const VkVideoDecodeInfoKHR* b,
                                     OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_dynamic_rendering
void checkEqual_VkRenderingAttachmentInfoKHR(const VkRenderingAttachmentInfoKHR* a,
                                             const VkRenderingAttachmentInfoKHR* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkRenderingInfoKHR(const VkRenderingInfoKHR* a, const VkRenderingInfoKHR* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkPipelineRenderingCreateInfoKHR(const VkPipelineRenderingCreateInfoKHR* a,
                                                 const VkPipelineRenderingCreateInfoKHR* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* a,
    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferInheritanceRenderingInfoKHR(
    const VkCommandBufferInheritanceRenderingInfoKHR* a,
    const VkCommandBufferInheritanceRenderingInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkRenderingFragmentShadingRateAttachmentInfoKHR(
    const VkRenderingFragmentShadingRateAttachmentInfoKHR* a,
    const VkRenderingFragmentShadingRateAttachmentInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkRenderingFragmentDensityMapAttachmentInfoEXT(
    const VkRenderingFragmentDensityMapAttachmentInfoEXT* a,
    const VkRenderingFragmentDensityMapAttachmentInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkAttachmentSampleCountInfoAMD(const VkAttachmentSampleCountInfoAMD* a,
                                               const VkAttachmentSampleCountInfoAMD* b,
                                               OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkAttachmentSampleCountInfoAMD,
                      checkEqual_VkAttachmentSampleCountInfoNV)

void checkEqual_VkMultiviewPerViewAttributesInfoNVX(const VkMultiviewPerViewAttributesInfoNVX* a,
                                                    const VkMultiviewPerViewAttributesInfoNVX* b,
                                                    OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_multiview
DEFINE_ALIAS_FUNCTION(checkEqual_VkRenderPassMultiviewCreateInfo,
                      checkEqual_VkRenderPassMultiviewCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMultiviewFeatures,
                      checkEqual_VkPhysicalDeviceMultiviewFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMultiviewProperties,
                      checkEqual_VkPhysicalDeviceMultiviewPropertiesKHR)

#endif
#ifdef VK_KHR_get_physical_device_properties2
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceFeatures2, checkEqual_VkPhysicalDeviceFeatures2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceProperties2,
                      checkEqual_VkPhysicalDeviceProperties2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkFormatProperties2, checkEqual_VkFormatProperties2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImageFormatProperties2, checkEqual_VkImageFormatProperties2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceImageFormatInfo2,
                      checkEqual_VkPhysicalDeviceImageFormatInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkQueueFamilyProperties2, checkEqual_VkQueueFamilyProperties2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMemoryProperties2,
                      checkEqual_VkPhysicalDeviceMemoryProperties2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSparseImageFormatProperties2,
                      checkEqual_VkSparseImageFormatProperties2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSparseImageFormatInfo2,
                      checkEqual_VkPhysicalDeviceSparseImageFormatInfo2KHR)

#endif
#ifdef VK_KHR_device_group
DEFINE_ALIAS_FUNCTION(checkEqual_VkMemoryAllocateFlagsInfo, checkEqual_VkMemoryAllocateFlagsInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceGroupRenderPassBeginInfo,
                      checkEqual_VkDeviceGroupRenderPassBeginInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceGroupCommandBufferBeginInfo,
                      checkEqual_VkDeviceGroupCommandBufferBeginInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceGroupSubmitInfo, checkEqual_VkDeviceGroupSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceGroupBindSparseInfo,
                      checkEqual_VkDeviceGroupBindSparseInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBindBufferMemoryDeviceGroupInfo,
                      checkEqual_VkBindBufferMemoryDeviceGroupInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBindImageMemoryDeviceGroupInfo,
                      checkEqual_VkBindImageMemoryDeviceGroupInfoKHR)

#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
#endif
#ifdef VK_KHR_device_group_creation
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceGroupProperties,
                      checkEqual_VkPhysicalDeviceGroupPropertiesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceGroupDeviceCreateInfo,
                      checkEqual_VkDeviceGroupDeviceCreateInfoKHR)

#endif
#ifdef VK_KHR_external_memory_capabilities
DEFINE_ALIAS_FUNCTION(checkEqual_VkExternalMemoryProperties,
                      checkEqual_VkExternalMemoryPropertiesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceExternalImageFormatInfo,
                      checkEqual_VkPhysicalDeviceExternalImageFormatInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkExternalImageFormatProperties,
                      checkEqual_VkExternalImageFormatPropertiesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceExternalBufferInfo,
                      checkEqual_VkPhysicalDeviceExternalBufferInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkExternalBufferProperties,
                      checkEqual_VkExternalBufferPropertiesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceIDProperties,
                      checkEqual_VkPhysicalDeviceIDPropertiesKHR)

#endif
#ifdef VK_KHR_external_memory
DEFINE_ALIAS_FUNCTION(checkEqual_VkExternalMemoryImageCreateInfo,
                      checkEqual_VkExternalMemoryImageCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkExternalMemoryBufferCreateInfo,
                      checkEqual_VkExternalMemoryBufferCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkExportMemoryAllocateInfo,
                      checkEqual_VkExportMemoryAllocateInfoKHR)

#endif
#ifdef VK_KHR_external_memory_win32
void checkEqual_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* a,
                                                 const VkImportMemoryWin32HandleInfoKHR* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* a,
                                                 const VkExportMemoryWin32HandleInfoKHR* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* a,
                                                 const VkMemoryWin32HandlePropertiesKHR* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* a,
                                              const VkMemoryGetWin32HandleInfoKHR* b,
                                              OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_external_memory_fd
void checkEqual_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* a,
                                        const VkImportMemoryFdInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* a,
                                        const VkMemoryFdPropertiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* a, const VkMemoryGetFdInfoKHR* b,
                                     OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_win32_keyed_mutex
void checkEqual_VkWin32KeyedMutexAcquireReleaseInfoKHR(
    const VkWin32KeyedMutexAcquireReleaseInfoKHR* a,
    const VkWin32KeyedMutexAcquireReleaseInfoKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_external_semaphore_capabilities
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceExternalSemaphoreInfo,
                      checkEqual_VkPhysicalDeviceExternalSemaphoreInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkExternalSemaphoreProperties,
                      checkEqual_VkExternalSemaphorePropertiesKHR)

#endif
#ifdef VK_KHR_external_semaphore
DEFINE_ALIAS_FUNCTION(checkEqual_VkExportSemaphoreCreateInfo,
                      checkEqual_VkExportSemaphoreCreateInfoKHR)

#endif
#ifdef VK_KHR_external_semaphore_win32
void checkEqual_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* a,
                                                    const VkImportSemaphoreWin32HandleInfoKHR* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* a,
                                                    const VkExportSemaphoreWin32HandleInfoKHR* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* a,
                                          const VkD3D12FenceSubmitInfoKHR* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* a,
                                                 const VkSemaphoreGetWin32HandleInfoKHR* b,
                                                 OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_external_semaphore_fd
void checkEqual_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* a,
                                           const VkImportSemaphoreFdInfoKHR* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* a,
                                        const VkSemaphoreGetFdInfoKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_push_descriptor
void checkEqual_VkPhysicalDevicePushDescriptorPropertiesKHR(
    const VkPhysicalDevicePushDescriptorPropertiesKHR* a,
    const VkPhysicalDevicePushDescriptorPropertiesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_shader_float16_int8
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderFloat16Int8Features,
                      checkEqual_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderFloat16Int8Features,
                      checkEqual_VkPhysicalDeviceFloat16Int8FeaturesKHR)

#endif
#ifdef VK_KHR_16bit_storage
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDevice16BitStorageFeatures,
                      checkEqual_VkPhysicalDevice16BitStorageFeaturesKHR)

#endif
#ifdef VK_KHR_incremental_present
void checkEqual_VkRectLayerKHR(const VkRectLayerKHR* a, const VkRectLayerKHR* b,
                               OnFailCompareFunc onFail);

void checkEqual_VkPresentRegionKHR(const VkPresentRegionKHR* a, const VkPresentRegionKHR* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkPresentRegionsKHR(const VkPresentRegionsKHR* a, const VkPresentRegionsKHR* b,
                                    OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_descriptor_update_template
DEFINE_ALIAS_FUNCTION(checkEqual_VkDescriptorUpdateTemplateEntry,
                      checkEqual_VkDescriptorUpdateTemplateEntryKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDescriptorUpdateTemplateCreateInfo,
                      checkEqual_VkDescriptorUpdateTemplateCreateInfoKHR)

#endif
#ifdef VK_KHR_imageless_framebuffer
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceImagelessFramebufferFeatures,
                      checkEqual_VkPhysicalDeviceImagelessFramebufferFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkFramebufferAttachmentsCreateInfo,
                      checkEqual_VkFramebufferAttachmentsCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkFramebufferAttachmentImageInfo,
                      checkEqual_VkFramebufferAttachmentImageInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkRenderPassAttachmentBeginInfo,
                      checkEqual_VkRenderPassAttachmentBeginInfoKHR)

#endif
#ifdef VK_KHR_create_renderpass2
DEFINE_ALIAS_FUNCTION(checkEqual_VkRenderPassCreateInfo2, checkEqual_VkRenderPassCreateInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkAttachmentDescription2, checkEqual_VkAttachmentDescription2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkAttachmentReference2, checkEqual_VkAttachmentReference2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSubpassDescription2, checkEqual_VkSubpassDescription2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSubpassDependency2, checkEqual_VkSubpassDependency2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSubpassBeginInfo, checkEqual_VkSubpassBeginInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSubpassEndInfo, checkEqual_VkSubpassEndInfoKHR)

#endif
#ifdef VK_KHR_shared_presentable_image
void checkEqual_VkSharedPresentSurfaceCapabilitiesKHR(
    const VkSharedPresentSurfaceCapabilitiesKHR* a, const VkSharedPresentSurfaceCapabilitiesKHR* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_external_fence_capabilities
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceExternalFenceInfo,
                      checkEqual_VkPhysicalDeviceExternalFenceInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkExternalFenceProperties, checkEqual_VkExternalFencePropertiesKHR)

#endif
#ifdef VK_KHR_external_fence
DEFINE_ALIAS_FUNCTION(checkEqual_VkExportFenceCreateInfo, checkEqual_VkExportFenceCreateInfoKHR)

#endif
#ifdef VK_KHR_external_fence_win32
void checkEqual_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* a,
                                                const VkImportFenceWin32HandleInfoKHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* a,
                                                const VkExportFenceWin32HandleInfoKHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* a,
                                             const VkFenceGetWin32HandleInfoKHR* b,
                                             OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_external_fence_fd
void checkEqual_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* a,
                                       const VkImportFenceFdInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* a, const VkFenceGetFdInfoKHR* b,
                                    OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_performance_query
void checkEqual_VkPhysicalDevicePerformanceQueryFeaturesKHR(
    const VkPhysicalDevicePerformanceQueryFeaturesKHR* a,
    const VkPhysicalDevicePerformanceQueryFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePerformanceQueryPropertiesKHR(
    const VkPhysicalDevicePerformanceQueryPropertiesKHR* a,
    const VkPhysicalDevicePerformanceQueryPropertiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPerformanceCounterKHR(const VkPerformanceCounterKHR* a,
                                        const VkPerformanceCounterKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPerformanceCounterDescriptionKHR(const VkPerformanceCounterDescriptionKHR* a,
                                                   const VkPerformanceCounterDescriptionKHR* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkQueryPoolPerformanceCreateInfoKHR(const VkQueryPoolPerformanceCreateInfoKHR* a,
                                                    const VkQueryPoolPerformanceCreateInfoKHR* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkPerformanceCounterResultKHR(const VkPerformanceCounterResultKHR* a,
                                              const VkPerformanceCounterResultKHR* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkAcquireProfilingLockInfoKHR(const VkAcquireProfilingLockInfoKHR* a,
                                              const VkAcquireProfilingLockInfoKHR* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkPerformanceQuerySubmitInfoKHR(const VkPerformanceQuerySubmitInfoKHR* a,
                                                const VkPerformanceQuerySubmitInfoKHR* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_maintenance2
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDevicePointClippingProperties,
                      checkEqual_VkPhysicalDevicePointClippingPropertiesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkRenderPassInputAttachmentAspectCreateInfo,
                      checkEqual_VkRenderPassInputAttachmentAspectCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkInputAttachmentAspectReference,
                      checkEqual_VkInputAttachmentAspectReferenceKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImageViewUsageCreateInfo,
                      checkEqual_VkImageViewUsageCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineTessellationDomainOriginStateCreateInfo,
                      checkEqual_VkPipelineTessellationDomainOriginStateCreateInfoKHR)

#endif
#ifdef VK_KHR_get_surface_capabilities2
void checkEqual_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* a,
                                                const VkPhysicalDeviceSurfaceInfo2KHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* a,
                                          const VkSurfaceCapabilities2KHR* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* a, const VkSurfaceFormat2KHR* b,
                                    OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_variable_pointers
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceVariablePointersFeatures,
                      checkEqual_VkPhysicalDeviceVariablePointerFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceVariablePointersFeatures,
                      checkEqual_VkPhysicalDeviceVariablePointersFeaturesKHR)

#endif
#ifdef VK_KHR_get_display_properties2
void checkEqual_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* a,
                                        const VkDisplayProperties2KHR* b, OnFailCompareFunc onFail);

void checkEqual_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* a,
                                             const VkDisplayPlaneProperties2KHR* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* a,
                                            const VkDisplayModeProperties2KHR* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* a,
                                       const VkDisplayPlaneInfo2KHR* b, OnFailCompareFunc onFail);

void checkEqual_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* a,
                                               const VkDisplayPlaneCapabilities2KHR* b,
                                               OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_dedicated_allocation
DEFINE_ALIAS_FUNCTION(checkEqual_VkMemoryDedicatedRequirements,
                      checkEqual_VkMemoryDedicatedRequirementsKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkMemoryDedicatedAllocateInfo,
                      checkEqual_VkMemoryDedicatedAllocateInfoKHR)

#endif
#ifdef VK_KHR_storage_buffer_storage_class
#endif
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferMemoryRequirementsInfo2,
                      checkEqual_VkBufferMemoryRequirementsInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImageMemoryRequirementsInfo2,
                      checkEqual_VkImageMemoryRequirementsInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImageSparseMemoryRequirementsInfo2,
                      checkEqual_VkImageSparseMemoryRequirementsInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkMemoryRequirements2, checkEqual_VkMemoryRequirements2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSparseImageMemoryRequirements2,
                      checkEqual_VkSparseImageMemoryRequirements2KHR)

#endif
#ifdef VK_KHR_image_format_list
DEFINE_ALIAS_FUNCTION(checkEqual_VkImageFormatListCreateInfo,
                      checkEqual_VkImageFormatListCreateInfoKHR)

#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
DEFINE_ALIAS_FUNCTION(checkEqual_VkSamplerYcbcrConversionCreateInfo,
                      checkEqual_VkSamplerYcbcrConversionCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSamplerYcbcrConversionInfo,
                      checkEqual_VkSamplerYcbcrConversionInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBindImagePlaneMemoryInfo,
                      checkEqual_VkBindImagePlaneMemoryInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImagePlaneMemoryRequirementsInfo,
                      checkEqual_VkImagePlaneMemoryRequirementsInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSamplerYcbcrConversionFeatures,
                      checkEqual_VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSamplerYcbcrConversionImageFormatProperties,
                      checkEqual_VkSamplerYcbcrConversionImageFormatPropertiesKHR)

#endif
#ifdef VK_KHR_bind_memory2
DEFINE_ALIAS_FUNCTION(checkEqual_VkBindBufferMemoryInfo, checkEqual_VkBindBufferMemoryInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBindImageMemoryInfo, checkEqual_VkBindImageMemoryInfoKHR)

#endif
#ifdef VK_KHR_portability_subset
void checkEqual_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
    const VkPhysicalDevicePortabilitySubsetFeaturesKHR* a,
    const VkPhysicalDevicePortabilitySubsetFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* a,
    const VkPhysicalDevicePortabilitySubsetPropertiesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_maintenance3
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMaintenance3Properties,
                      checkEqual_VkPhysicalDeviceMaintenance3PropertiesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDescriptorSetLayoutSupport,
                      checkEqual_VkDescriptorSetLayoutSupportKHR)

#endif
#ifdef VK_KHR_draw_indirect_count
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures,
                      checkEqual_VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR)

#endif
#ifdef VK_KHR_8bit_storage
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDevice8BitStorageFeatures,
                      checkEqual_VkPhysicalDevice8BitStorageFeaturesKHR)

#endif
#ifdef VK_KHR_shader_atomic_int64
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderAtomicInt64Features,
                      checkEqual_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR)

#endif
#ifdef VK_KHR_shader_clock
void checkEqual_VkPhysicalDeviceShaderClockFeaturesKHR(
    const VkPhysicalDeviceShaderClockFeaturesKHR* a,
    const VkPhysicalDeviceShaderClockFeaturesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_driver_properties
DEFINE_ALIAS_FUNCTION(checkEqual_VkConformanceVersion, checkEqual_VkConformanceVersionKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceDriverProperties,
                      checkEqual_VkPhysicalDeviceDriverPropertiesKHR)

#endif
#ifdef VK_KHR_shader_float_controls
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceFloatControlsProperties,
                      checkEqual_VkPhysicalDeviceFloatControlsPropertiesKHR)

#endif
#ifdef VK_KHR_depth_stencil_resolve
DEFINE_ALIAS_FUNCTION(checkEqual_VkSubpassDescriptionDepthStencilResolve,
                      checkEqual_VkSubpassDescriptionDepthStencilResolveKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceDepthStencilResolveProperties,
                      checkEqual_VkPhysicalDeviceDepthStencilResolvePropertiesKHR)

#endif
#ifdef VK_KHR_swapchain_mutable_format
#endif
#ifdef VK_KHR_timeline_semaphore
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceTimelineSemaphoreFeatures,
                      checkEqual_VkPhysicalDeviceTimelineSemaphoreFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceTimelineSemaphoreProperties,
                      checkEqual_VkPhysicalDeviceTimelineSemaphorePropertiesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSemaphoreTypeCreateInfo, checkEqual_VkSemaphoreTypeCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkTimelineSemaphoreSubmitInfo,
                      checkEqual_VkTimelineSemaphoreSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSemaphoreWaitInfo, checkEqual_VkSemaphoreWaitInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSemaphoreSignalInfo, checkEqual_VkSemaphoreSignalInfoKHR)

#endif
#ifdef VK_KHR_vulkan_memory_model
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceVulkanMemoryModelFeatures,
                      checkEqual_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR)

#endif
#ifdef VK_KHR_shader_terminate_invocation
void checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* a,
    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_fragment_shading_rate
void checkEqual_VkFragmentShadingRateAttachmentInfoKHR(
    const VkFragmentShadingRateAttachmentInfoKHR* a,
    const VkFragmentShadingRateAttachmentInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineFragmentShadingRateStateCreateInfoKHR(
    const VkPipelineFragmentShadingRateStateCreateInfoKHR* a,
    const VkPipelineFragmentShadingRateStateCreateInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* a,
    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* a,
    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFragmentShadingRateKHR(
    const VkPhysicalDeviceFragmentShadingRateKHR* a,
    const VkPhysicalDeviceFragmentShadingRateKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_spirv_1_4
#endif
#ifdef VK_KHR_surface_protected_capabilities
void checkEqual_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* a,
                                                  const VkSurfaceProtectedCapabilitiesKHR* b,
                                                  OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_separate_depth_stencil_layouts
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures,
                      checkEqual_VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkAttachmentReferenceStencilLayout,
                      checkEqual_VkAttachmentReferenceStencilLayoutKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkAttachmentDescriptionStencilLayout,
                      checkEqual_VkAttachmentDescriptionStencilLayoutKHR)

#endif
#ifdef VK_KHR_present_wait
void checkEqual_VkPhysicalDevicePresentWaitFeaturesKHR(
    const VkPhysicalDevicePresentWaitFeaturesKHR* a,
    const VkPhysicalDevicePresentWaitFeaturesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_uniform_buffer_standard_layout
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceUniformBufferStandardLayoutFeatures,
                      checkEqual_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR)

#endif
#ifdef VK_KHR_buffer_device_address
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceBufferDeviceAddressFeatures,
                      checkEqual_VkPhysicalDeviceBufferDeviceAddressFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferDeviceAddressInfo, checkEqual_VkBufferDeviceAddressInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferOpaqueCaptureAddressCreateInfo,
                      checkEqual_VkBufferOpaqueCaptureAddressCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkMemoryOpaqueCaptureAddressAllocateInfo,
                      checkEqual_VkMemoryOpaqueCaptureAddressAllocateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceMemoryOpaqueCaptureAddressInfo,
                      checkEqual_VkDeviceMemoryOpaqueCaptureAddressInfoKHR)

#endif
#ifdef VK_KHR_deferred_host_operations
#endif
#ifdef VK_KHR_pipeline_executable_properties
void checkEqual_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* a,
    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineInfoKHR(const VkPipelineInfoKHR* a, const VkPipelineInfoKHR* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* a,
                                                  const VkPipelineExecutablePropertiesKHR* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* a,
                                            const VkPipelineExecutableInfoKHR* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkPipelineExecutableStatisticValueKHR(
    const VkPipelineExecutableStatisticValueKHR* a, const VkPipelineExecutableStatisticValueKHR* b,
    OnFailCompareFunc onFail);

void checkEqual_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* a,
                                                 const VkPipelineExecutableStatisticKHR* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPipelineExecutableInternalRepresentationKHR(
    const VkPipelineExecutableInternalRepresentationKHR* a,
    const VkPipelineExecutableInternalRepresentationKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_shader_integer_dot_product
void checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* a,
    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* a,
    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_pipeline_library
void checkEqual_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* a,
                                               const VkPipelineLibraryCreateInfoKHR* b,
                                               OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_present_id
void checkEqual_VkPresentIdKHR(const VkPresentIdKHR* a, const VkPresentIdKHR* b,
                               OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePresentIdFeaturesKHR* a,
                                                     const VkPhysicalDevicePresentIdFeaturesKHR* b,
                                                     OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_video_encode_queue
void checkEqual_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* a, const VkVideoEncodeInfoKHR* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* a,
                                                const VkVideoEncodeRateControlInfoKHR* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_synchronization2
void checkEqual_VkMemoryBarrier2KHR(const VkMemoryBarrier2KHR* a, const VkMemoryBarrier2KHR* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR* a,
                                          const VkBufferMemoryBarrier2KHR* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR* a,
                                         const VkImageMemoryBarrier2KHR* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkDependencyInfoKHR(const VkDependencyInfoKHR* a, const VkDependencyInfoKHR* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR* a,
                                         const VkSemaphoreSubmitInfoKHR* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR* a,
                                             const VkCommandBufferSubmitInfoKHR* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkSubmitInfo2KHR(const VkSubmitInfo2KHR* a, const VkSubmitInfo2KHR* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSynchronization2FeaturesKHR(
    const VkPhysicalDeviceSynchronization2FeaturesKHR* a,
    const VkPhysicalDeviceSynchronization2FeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* a,
                                                     const VkQueueFamilyCheckpointProperties2NV* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkCheckpointData2NV(const VkCheckpointData2NV* a, const VkCheckpointData2NV* b,
                                    OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_shader_subgroup_uniform_control_flow
void checkEqual_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* a,
    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
void checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* a,
    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_workgroup_memory_explicit_layout
void checkEqual_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* a,
    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_copy_commands2
void checkEqual_VkBufferCopy2KHR(const VkBufferCopy2KHR* a, const VkBufferCopy2KHR* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR* a, const VkCopyBufferInfo2KHR* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkImageCopy2KHR(const VkImageCopy2KHR* a, const VkImageCopy2KHR* b,
                                OnFailCompareFunc onFail);

void checkEqual_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR* a, const VkCopyImageInfo2KHR* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR* a,
                                      const VkBufferImageCopy2KHR* b, OnFailCompareFunc onFail);

void checkEqual_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR* a,
                                            const VkCopyBufferToImageInfo2KHR* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR* a,
                                            const VkCopyImageToBufferInfo2KHR* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkImageBlit2KHR(const VkImageBlit2KHR* a, const VkImageBlit2KHR* b,
                                OnFailCompareFunc onFail);

void checkEqual_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR* a, const VkBlitImageInfo2KHR* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkImageResolve2KHR(const VkImageResolve2KHR* a, const VkImageResolve2KHR* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR* a,
                                       const VkResolveImageInfo2KHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_format_feature_flags2
void checkEqual_VkFormatProperties3KHR(const VkFormatProperties3KHR* a,
                                       const VkFormatProperties3KHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_maintenance4
void checkEqual_VkPhysicalDeviceMaintenance4FeaturesKHR(
    const VkPhysicalDeviceMaintenance4FeaturesKHR* a,
    const VkPhysicalDeviceMaintenance4FeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMaintenance4PropertiesKHR(
    const VkPhysicalDeviceMaintenance4PropertiesKHR* a,
    const VkPhysicalDeviceMaintenance4PropertiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceBufferMemoryRequirementsKHR(const VkDeviceBufferMemoryRequirementsKHR* a,
                                                    const VkDeviceBufferMemoryRequirementsKHR* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkDeviceImageMemoryRequirementsKHR(const VkDeviceImageMemoryRequirementsKHR* a,
                                                   const VkDeviceImageMemoryRequirementsKHR* b,
                                                   OnFailCompareFunc onFail);

#endif
#ifdef VK_ANDROID_native_buffer
void checkEqual_VkNativeBufferANDROID(const VkNativeBufferANDROID* a,
                                      const VkNativeBufferANDROID* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_debug_report
void checkEqual_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* a,
                                                   const VkDebugReportCallbackCreateInfoEXT* b,
                                                   OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_glsl_shader
#endif
#ifdef VK_EXT_depth_range_unrestricted
#endif
#ifdef VK_IMG_filter_cubic
#endif
#ifdef VK_AMD_rasterization_order
void checkEqual_VkPipelineRasterizationStateRasterizationOrderAMD(
    const VkPipelineRasterizationStateRasterizationOrderAMD* a,
    const VkPipelineRasterizationStateRasterizationOrderAMD* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_shader_trinary_minmax
#endif
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
void checkEqual_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* a,
                                               const VkDebugMarkerObjectNameInfoEXT* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* a,
                                              const VkDebugMarkerObjectTagInfoEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* a,
                                           const VkDebugMarkerMarkerInfoEXT* b,
                                           OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
void checkEqual_VkDedicatedAllocationImageCreateInfoNV(
    const VkDedicatedAllocationImageCreateInfoNV* a,
    const VkDedicatedAllocationImageCreateInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkDedicatedAllocationBufferCreateInfoNV(
    const VkDedicatedAllocationBufferCreateInfoNV* a,
    const VkDedicatedAllocationBufferCreateInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkDedicatedAllocationMemoryAllocateInfoNV(
    const VkDedicatedAllocationMemoryAllocateInfoNV* a,
    const VkDedicatedAllocationMemoryAllocateInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_transform_feedback
void checkEqual_VkPhysicalDeviceTransformFeedbackFeaturesEXT(
    const VkPhysicalDeviceTransformFeedbackFeaturesEXT* a,
    const VkPhysicalDeviceTransformFeedbackFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceTransformFeedbackPropertiesEXT(
    const VkPhysicalDeviceTransformFeedbackPropertiesEXT* a,
    const VkPhysicalDeviceTransformFeedbackPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineRasterizationStateStreamCreateInfoEXT(
    const VkPipelineRasterizationStateStreamCreateInfoEXT* a,
    const VkPipelineRasterizationStateStreamCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NVX_binary_import
void checkEqual_VkCuModuleCreateInfoNVX(const VkCuModuleCreateInfoNVX* a,
                                        const VkCuModuleCreateInfoNVX* b, OnFailCompareFunc onFail);

void checkEqual_VkCuFunctionCreateInfoNVX(const VkCuFunctionCreateInfoNVX* a,
                                          const VkCuFunctionCreateInfoNVX* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkCuLaunchInfoNVX(const VkCuLaunchInfoNVX* a, const VkCuLaunchInfoNVX* b,
                                  OnFailCompareFunc onFail);

#endif
#ifdef VK_NVX_image_view_handle
void checkEqual_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* a,
                                         const VkImageViewHandleInfoNVX* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkImageViewAddressPropertiesNVX(const VkImageViewAddressPropertiesNVX* a,
                                                const VkImageViewAddressPropertiesNVX* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_draw_indirect_count
#endif
#ifdef VK_AMD_negative_viewport_height
#endif
#ifdef VK_AMD_gpu_shader_half_float
#endif
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_EXT_video_encode_h264
void checkEqual_VkVideoEncodeH264CapabilitiesEXT(const VkVideoEncodeH264CapabilitiesEXT* a,
                                                 const VkVideoEncodeH264CapabilitiesEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264SessionCreateInfoEXT(
    const VkVideoEncodeH264SessionCreateInfoEXT* a, const VkVideoEncodeH264SessionCreateInfoEXT* b,
    OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264SessionParametersAddInfoEXT(
    const VkVideoEncodeH264SessionParametersAddInfoEXT* a,
    const VkVideoEncodeH264SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264SessionParametersCreateInfoEXT(
    const VkVideoEncodeH264SessionParametersCreateInfoEXT* a,
    const VkVideoEncodeH264SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(const VkVideoEncodeH264DpbSlotInfoEXT* a,
                                                const VkVideoEncodeH264DpbSlotInfoEXT* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264NaluSliceEXT(const VkVideoEncodeH264NaluSliceEXT* a,
                                              const VkVideoEncodeH264NaluSliceEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264VclFrameInfoEXT(const VkVideoEncodeH264VclFrameInfoEXT* a,
                                                 const VkVideoEncodeH264VclFrameInfoEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264EmitPictureParametersEXT(
    const VkVideoEncodeH264EmitPictureParametersEXT* a,
    const VkVideoEncodeH264EmitPictureParametersEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264ProfileEXT(const VkVideoEncodeH264ProfileEXT* a,
                                            const VkVideoEncodeH264ProfileEXT* b,
                                            OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_video_encode_h265
void checkEqual_VkVideoEncodeH265CapabilitiesEXT(const VkVideoEncodeH265CapabilitiesEXT* a,
                                                 const VkVideoEncodeH265CapabilitiesEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265SessionCreateInfoEXT(
    const VkVideoEncodeH265SessionCreateInfoEXT* a, const VkVideoEncodeH265SessionCreateInfoEXT* b,
    OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265SessionParametersAddInfoEXT(
    const VkVideoEncodeH265SessionParametersAddInfoEXT* a,
    const VkVideoEncodeH265SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265SessionParametersCreateInfoEXT(
    const VkVideoEncodeH265SessionParametersCreateInfoEXT* a,
    const VkVideoEncodeH265SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265DpbSlotInfoEXT(const VkVideoEncodeH265DpbSlotInfoEXT* a,
                                                const VkVideoEncodeH265DpbSlotInfoEXT* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265ReferenceListsEXT(const VkVideoEncodeH265ReferenceListsEXT* a,
                                                   const VkVideoEncodeH265ReferenceListsEXT* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265NaluSliceEXT(const VkVideoEncodeH265NaluSliceEXT* a,
                                              const VkVideoEncodeH265NaluSliceEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265VclFrameInfoEXT(const VkVideoEncodeH265VclFrameInfoEXT* a,
                                                 const VkVideoEncodeH265VclFrameInfoEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265EmitPictureParametersEXT(
    const VkVideoEncodeH265EmitPictureParametersEXT* a,
    const VkVideoEncodeH265EmitPictureParametersEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265ProfileEXT(const VkVideoEncodeH265ProfileEXT* a,
                                            const VkVideoEncodeH265ProfileEXT* b,
                                            OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_video_decode_h264
void checkEqual_VkVideoDecodeH264ProfileEXT(const VkVideoDecodeH264ProfileEXT* a,
                                            const VkVideoDecodeH264ProfileEXT* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264CapabilitiesEXT(const VkVideoDecodeH264CapabilitiesEXT* a,
                                                 const VkVideoDecodeH264CapabilitiesEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264SessionCreateInfoEXT(
    const VkVideoDecodeH264SessionCreateInfoEXT* a, const VkVideoDecodeH264SessionCreateInfoEXT* b,
    OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264SessionParametersAddInfoEXT(
    const VkVideoDecodeH264SessionParametersAddInfoEXT* a,
    const VkVideoDecodeH264SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264SessionParametersCreateInfoEXT(
    const VkVideoDecodeH264SessionParametersCreateInfoEXT* a,
    const VkVideoDecodeH264SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264PictureInfoEXT(const VkVideoDecodeH264PictureInfoEXT* a,
                                                const VkVideoDecodeH264PictureInfoEXT* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264MvcEXT(const VkVideoDecodeH264MvcEXT* a,
                                        const VkVideoDecodeH264MvcEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264DpbSlotInfoEXT(const VkVideoDecodeH264DpbSlotInfoEXT* a,
                                                const VkVideoDecodeH264DpbSlotInfoEXT* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_texture_gather_bias_lod
void checkEqual_VkTextureLODGatherFormatPropertiesAMD(
    const VkTextureLODGatherFormatPropertiesAMD* a, const VkTextureLODGatherFormatPropertiesAMD* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_shader_info
void checkEqual_VkShaderResourceUsageAMD(const VkShaderResourceUsageAMD* a,
                                         const VkShaderResourceUsageAMD* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkShaderStatisticsInfoAMD(const VkShaderStatisticsInfoAMD* a,
                                          const VkShaderStatisticsInfoAMD* b,
                                          OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_GGP_stream_descriptor_surface
void checkEqual_VkStreamDescriptorSurfaceCreateInfoGGP(
    const VkStreamDescriptorSurfaceCreateInfoGGP* a,
    const VkStreamDescriptorSurfaceCreateInfoGGP* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_corner_sampled_image
void checkEqual_VkPhysicalDeviceCornerSampledImageFeaturesNV(
    const VkPhysicalDeviceCornerSampledImageFeaturesNV* a,
    const VkPhysicalDeviceCornerSampledImageFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
void checkEqual_VkExternalImageFormatPropertiesNV(const VkExternalImageFormatPropertiesNV* a,
                                                  const VkExternalImageFormatPropertiesNV* b,
                                                  OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_external_memory
void checkEqual_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* a,
                                                  const VkExternalMemoryImageCreateInfoNV* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* a,
                                             const VkExportMemoryAllocateInfoNV* b,
                                             OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_external_memory_win32
void checkEqual_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* a,
                                                const VkImportMemoryWin32HandleInfoNV* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* a,
                                                const VkExportMemoryWin32HandleInfoNV* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_win32_keyed_mutex
void checkEqual_VkWin32KeyedMutexAcquireReleaseInfoNV(
    const VkWin32KeyedMutexAcquireReleaseInfoNV* a, const VkWin32KeyedMutexAcquireReleaseInfoNV* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_validation_flags
void checkEqual_VkValidationFlagsEXT(const VkValidationFlagsEXT* a, const VkValidationFlagsEXT* b,
                                     OnFailCompareFunc onFail);

#endif
#ifdef VK_NN_vi_surface
void checkEqual_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* a,
                                        const VkViSurfaceCreateInfoNN* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_subgroup_ballot
#endif
#ifdef VK_EXT_shader_subgroup_vote
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
void checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* a,
    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_astc_decode_mode
void checkEqual_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* a,
                                             const VkImageViewASTCDecodeModeEXT* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceASTCDecodeFeaturesEXT(
    const VkPhysicalDeviceASTCDecodeFeaturesEXT* a, const VkPhysicalDeviceASTCDecodeFeaturesEXT* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_conditional_rendering
void checkEqual_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* a,
                                                   const VkConditionalRenderingBeginInfoEXT* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* a,
    const VkPhysicalDeviceConditionalRenderingFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferInheritanceConditionalRenderingInfoEXT(
    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* a,
    const VkCommandBufferInheritanceConditionalRenderingInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_clip_space_w_scaling
void checkEqual_VkViewportWScalingNV(const VkViewportWScalingNV* a, const VkViewportWScalingNV* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkPipelineViewportWScalingStateCreateInfoNV(
    const VkPipelineViewportWScalingStateCreateInfoNV* a,
    const VkPipelineViewportWScalingStateCreateInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_direct_mode_display
#endif
#ifdef VK_EXT_acquire_xlib_display
#endif
#ifdef VK_EXT_display_surface_counter
void checkEqual_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* a,
                                          const VkSurfaceCapabilities2EXT* b,
                                          OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_display_control
void checkEqual_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* a,
                                      const VkDisplayPowerInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* a, const VkDeviceEventInfoEXT* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* a,
                                      const VkDisplayEventInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* a,
                                                const VkSwapchainCounterCreateInfoEXT* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_GOOGLE_display_timing
void checkEqual_VkRefreshCycleDurationGOOGLE(const VkRefreshCycleDurationGOOGLE* a,
                                             const VkRefreshCycleDurationGOOGLE* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkPastPresentationTimingGOOGLE(const VkPastPresentationTimingGOOGLE* a,
                                               const VkPastPresentationTimingGOOGLE* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkPresentTimeGOOGLE(const VkPresentTimeGOOGLE* a, const VkPresentTimeGOOGLE* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* a,
                                         const VkPresentTimesInfoGOOGLE* b,
                                         OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_sample_mask_override_coverage
#endif
#ifdef VK_NV_geometry_shader_passthrough
#endif
#ifdef VK_NV_viewport_array2
#endif
#ifdef VK_NVX_multiview_per_view_attributes
void checkEqual_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(
    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* a,
    const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_viewport_swizzle
void checkEqual_VkViewportSwizzleNV(const VkViewportSwizzleNV* a, const VkViewportSwizzleNV* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkPipelineViewportSwizzleStateCreateInfoNV(
    const VkPipelineViewportSwizzleStateCreateInfoNV* a,
    const VkPipelineViewportSwizzleStateCreateInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_discard_rectangles
void checkEqual_VkPhysicalDeviceDiscardRectanglePropertiesEXT(
    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* a,
    const VkPhysicalDeviceDiscardRectanglePropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineDiscardRectangleStateCreateInfoEXT(
    const VkPipelineDiscardRectangleStateCreateInfoEXT* a,
    const VkPipelineDiscardRectangleStateCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_conservative_rasterization
void checkEqual_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* a,
    const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineRasterizationConservativeStateCreateInfoEXT(
    const VkPipelineRasterizationConservativeStateCreateInfoEXT* a,
    const VkPipelineRasterizationConservativeStateCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_depth_clip_enable
void checkEqual_VkPhysicalDeviceDepthClipEnableFeaturesEXT(
    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* a,
    const VkPhysicalDeviceDepthClipEnableFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineRasterizationDepthClipStateCreateInfoEXT(
    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* a,
    const VkPipelineRasterizationDepthClipStateCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
void checkEqual_VkXYColorEXT(const VkXYColorEXT* a, const VkXYColorEXT* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkHdrMetadataEXT(const VkHdrMetadataEXT* a, const VkHdrMetadataEXT* b,
                                 OnFailCompareFunc onFail);

#endif
#ifdef VK_MVK_ios_surface
void checkEqual_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK* a,
                                          const VkIOSSurfaceCreateInfoMVK* b,
                                          OnFailCompareFunc onFail);

#endif
#ifdef VK_MVK_macos_surface
void checkEqual_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* a,
                                            const VkMacOSSurfaceCreateInfoMVK* b,
                                            OnFailCompareFunc onFail);

#endif
#ifdef VK_MVK_moltenvk
#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
void checkEqual_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* a, const VkDebugUtilsLabelEXT* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* a,
                                              const VkDebugUtilsObjectNameInfoEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* a,
                                                     const VkDebugUtilsMessengerCallbackDataEXT* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* a,
                                                   const VkDebugUtilsMessengerCreateInfoEXT* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* a,
                                             const VkDebugUtilsObjectTagInfoEXT* b,
                                             OnFailCompareFunc onFail);

#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void checkEqual_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID* a,
                                                    const VkAndroidHardwareBufferUsageANDROID* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkAndroidHardwareBufferPropertiesANDROID(
    const VkAndroidHardwareBufferPropertiesANDROID* a,
    const VkAndroidHardwareBufferPropertiesANDROID* b, OnFailCompareFunc onFail);

void checkEqual_VkAndroidHardwareBufferFormatPropertiesANDROID(
    const VkAndroidHardwareBufferFormatPropertiesANDROID* a,
    const VkAndroidHardwareBufferFormatPropertiesANDROID* b, OnFailCompareFunc onFail);

void checkEqual_VkImportAndroidHardwareBufferInfoANDROID(
    const VkImportAndroidHardwareBufferInfoANDROID* a,
    const VkImportAndroidHardwareBufferInfoANDROID* b, OnFailCompareFunc onFail);

void checkEqual_VkMemoryGetAndroidHardwareBufferInfoANDROID(
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* a,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* b, OnFailCompareFunc onFail);

void checkEqual_VkExternalFormatANDROID(const VkExternalFormatANDROID* a,
                                        const VkExternalFormatANDROID* b, OnFailCompareFunc onFail);

void checkEqual_VkAndroidHardwareBufferFormatProperties2ANDROID(
    const VkAndroidHardwareBufferFormatProperties2ANDROID* a,
    const VkAndroidHardwareBufferFormatProperties2ANDROID* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_sampler_filter_minmax
DEFINE_ALIAS_FUNCTION(checkEqual_VkSamplerReductionModeCreateInfo,
                      checkEqual_VkSamplerReductionModeCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSamplerFilterMinmaxProperties,
                      checkEqual_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT)

#endif
#ifdef VK_AMD_gpu_shader_int16
#endif
#ifdef VK_AMD_mixed_attachment_samples
#endif
#ifdef VK_AMD_shader_fragment_mask
#endif
#ifdef VK_EXT_inline_uniform_block
void checkEqual_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* a,
    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* a,
    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkWriteDescriptorSetInlineUniformBlockEXT(
    const VkWriteDescriptorSetInlineUniformBlockEXT* a,
    const VkWriteDescriptorSetInlineUniformBlockEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* a,
    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
void checkEqual_VkSampleLocationEXT(const VkSampleLocationEXT* a, const VkSampleLocationEXT* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* a,
                                         const VkSampleLocationsInfoEXT* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkAttachmentSampleLocationsEXT(const VkAttachmentSampleLocationsEXT* a,
                                               const VkAttachmentSampleLocationsEXT* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkSubpassSampleLocationsEXT(const VkSubpassSampleLocationsEXT* a,
                                            const VkSubpassSampleLocationsEXT* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkRenderPassSampleLocationsBeginInfoEXT(
    const VkRenderPassSampleLocationsBeginInfoEXT* a,
    const VkRenderPassSampleLocationsBeginInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineSampleLocationsStateCreateInfoEXT(
    const VkPipelineSampleLocationsStateCreateInfoEXT* a,
    const VkPipelineSampleLocationsStateCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSampleLocationsPropertiesEXT(
    const VkPhysicalDeviceSampleLocationsPropertiesEXT* a,
    const VkPhysicalDeviceSampleLocationsPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* a,
                                           const VkMultisamplePropertiesEXT* b,
                                           OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_blend_operation_advanced
void checkEqual_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(
    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* a,
    const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(
    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* a,
    const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineColorBlendAdvancedStateCreateInfoEXT(
    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* a,
    const VkPipelineColorBlendAdvancedStateCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_fragment_coverage_to_color
void checkEqual_VkPipelineCoverageToColorStateCreateInfoNV(
    const VkPipelineCoverageToColorStateCreateInfoNV* a,
    const VkPipelineCoverageToColorStateCreateInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_framebuffer_mixed_samples
void checkEqual_VkPipelineCoverageModulationStateCreateInfoNV(
    const VkPipelineCoverageModulationStateCreateInfoNV* a,
    const VkPipelineCoverageModulationStateCreateInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_NV_shader_sm_builtins
void checkEqual_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(
    const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* a,
    const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(
    const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* a,
    const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_image_drm_format_modifier
void checkEqual_VkDrmFormatModifierPropertiesEXT(const VkDrmFormatModifierPropertiesEXT* a,
                                                 const VkDrmFormatModifierPropertiesEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* a,
                                                     const VkDrmFormatModifierPropertiesListEXT* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(
    const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* a,
    const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkImageDrmFormatModifierListCreateInfoEXT(
    const VkImageDrmFormatModifierListCreateInfoEXT* a,
    const VkImageDrmFormatModifierListCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkImageDrmFormatModifierExplicitCreateInfoEXT(
    const VkImageDrmFormatModifierExplicitCreateInfoEXT* a,
    const VkImageDrmFormatModifierExplicitCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkImageDrmFormatModifierPropertiesEXT(
    const VkImageDrmFormatModifierPropertiesEXT* a, const VkImageDrmFormatModifierPropertiesEXT* b,
    OnFailCompareFunc onFail);

void checkEqual_VkDrmFormatModifierProperties2EXT(const VkDrmFormatModifierProperties2EXT* a,
                                                  const VkDrmFormatModifierProperties2EXT* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkDrmFormatModifierPropertiesList2EXT(
    const VkDrmFormatModifierPropertiesList2EXT* a, const VkDrmFormatModifierPropertiesList2EXT* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_validation_cache
void checkEqual_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* a,
                                               const VkValidationCacheCreateInfoEXT* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkShaderModuleValidationCacheCreateInfoEXT(
    const VkShaderModuleValidationCacheCreateInfoEXT* a,
    const VkShaderModuleValidationCacheCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_descriptor_indexing
DEFINE_ALIAS_FUNCTION(checkEqual_VkDescriptorSetLayoutBindingFlagsCreateInfo,
                      checkEqual_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceDescriptorIndexingFeatures,
                      checkEqual_VkPhysicalDeviceDescriptorIndexingFeaturesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceDescriptorIndexingProperties,
                      checkEqual_VkPhysicalDeviceDescriptorIndexingPropertiesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDescriptorSetVariableDescriptorCountAllocateInfo,
                      checkEqual_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDescriptorSetVariableDescriptorCountLayoutSupport,
                      checkEqual_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT)

#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_NV_shading_rate_image
void checkEqual_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* a,
                                       const VkShadingRatePaletteNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineViewportShadingRateImageStateCreateInfoNV(
    const VkPipelineViewportShadingRateImageStateCreateInfoNV* a,
    const VkPipelineViewportShadingRateImageStateCreateInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShadingRateImageFeaturesNV(
    const VkPhysicalDeviceShadingRateImageFeaturesNV* a,
    const VkPhysicalDeviceShadingRateImageFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShadingRateImagePropertiesNV(
    const VkPhysicalDeviceShadingRateImagePropertiesNV* a,
    const VkPhysicalDeviceShadingRateImagePropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkCoarseSampleLocationNV(const VkCoarseSampleLocationNV* a,
                                         const VkCoarseSampleLocationNV* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* a,
                                            const VkCoarseSampleOrderCustomNV* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(
    const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* a,
    const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_ray_tracing
void checkEqual_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV* a,
                                                    const VkRayTracingShaderGroupCreateInfoNV* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* a,
                                                 const VkRayTracingPipelineCreateInfoNV* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* a,
                                      const VkGeometryTrianglesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkGeometryAABBNV(const VkGeometryAABBNV* a, const VkGeometryAABBNV* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkGeometryDataNV(const VkGeometryDataNV* a, const VkGeometryDataNV* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkGeometryNV(const VkGeometryNV* a, const VkGeometryNV* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* a,
                                              const VkAccelerationStructureInfoNV* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV* a,
                                                    const VkAccelerationStructureCreateInfoNV* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkBindAccelerationStructureMemoryInfoNV(
    const VkBindAccelerationStructureMemoryInfoNV* a,
    const VkBindAccelerationStructureMemoryInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkWriteDescriptorSetAccelerationStructureNV(
    const VkWriteDescriptorSetAccelerationStructureNV* a,
    const VkWriteDescriptorSetAccelerationStructureNV* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureMemoryRequirementsInfoNV(
    const VkAccelerationStructureMemoryRequirementsInfoNV* a,
    const VkAccelerationStructureMemoryRequirementsInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceRayTracingPropertiesNV(
    const VkPhysicalDeviceRayTracingPropertiesNV* a,
    const VkPhysicalDeviceRayTracingPropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkTransformMatrixKHR(const VkTransformMatrixKHR* a, const VkTransformMatrixKHR* b,
                                     OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkTransformMatrixKHR, checkEqual_VkTransformMatrixNV)

void checkEqual_VkAabbPositionsKHR(const VkAabbPositionsKHR* a, const VkAabbPositionsKHR* b,
                                   OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkAabbPositionsKHR, checkEqual_VkAabbPositionsNV)

void checkEqual_VkAccelerationStructureInstanceKHR(const VkAccelerationStructureInstanceKHR* a,
                                                   const VkAccelerationStructureInstanceKHR* b,
                                                   OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkAccelerationStructureInstanceKHR,
                      checkEqual_VkAccelerationStructureInstanceNV)

#endif
#ifdef VK_NV_representative_fragment_test
void checkEqual_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(
    const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* a,
    const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(
    const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* a,
    const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_filter_cubic
void checkEqual_VkPhysicalDeviceImageViewImageFormatInfoEXT(
    const VkPhysicalDeviceImageViewImageFormatInfoEXT* a,
    const VkPhysicalDeviceImageViewImageFormatInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkFilterCubicImageViewImageFormatPropertiesEXT(
    const VkFilterCubicImageViewImageFormatPropertiesEXT* a,
    const VkFilterCubicImageViewImageFormatPropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_QCOM_render_pass_shader_resolve
#endif
#ifdef VK_EXT_global_priority
void checkEqual_VkDeviceQueueGlobalPriorityCreateInfoEXT(
    const VkDeviceQueueGlobalPriorityCreateInfoEXT* a,
    const VkDeviceQueueGlobalPriorityCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_external_memory_host
void checkEqual_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* a,
                                                 const VkImportMemoryHostPointerInfoEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* a,
                                                 const VkMemoryHostPointerPropertiesEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(
    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* a,
    const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_buffer_marker
#endif
#ifdef VK_AMD_pipeline_compiler_control
void checkEqual_VkPipelineCompilerControlCreateInfoAMD(
    const VkPipelineCompilerControlCreateInfoAMD* a,
    const VkPipelineCompilerControlCreateInfoAMD* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_calibrated_timestamps
void checkEqual_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT* a,
                                             const VkCalibratedTimestampInfoEXT* b,
                                             OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_shader_core_properties
void checkEqual_VkPhysicalDeviceShaderCorePropertiesAMD(
    const VkPhysicalDeviceShaderCorePropertiesAMD* a,
    const VkPhysicalDeviceShaderCorePropertiesAMD* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_video_decode_h265
void checkEqual_VkVideoDecodeH265ProfileEXT(const VkVideoDecodeH265ProfileEXT* a,
                                            const VkVideoDecodeH265ProfileEXT* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265CapabilitiesEXT(const VkVideoDecodeH265CapabilitiesEXT* a,
                                                 const VkVideoDecodeH265CapabilitiesEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265SessionCreateInfoEXT(
    const VkVideoDecodeH265SessionCreateInfoEXT* a, const VkVideoDecodeH265SessionCreateInfoEXT* b,
    OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265SessionParametersAddInfoEXT(
    const VkVideoDecodeH265SessionParametersAddInfoEXT* a,
    const VkVideoDecodeH265SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265SessionParametersCreateInfoEXT(
    const VkVideoDecodeH265SessionParametersCreateInfoEXT* a,
    const VkVideoDecodeH265SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265PictureInfoEXT(const VkVideoDecodeH265PictureInfoEXT* a,
                                                const VkVideoDecodeH265PictureInfoEXT* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265DpbSlotInfoEXT(const VkVideoDecodeH265DpbSlotInfoEXT* a,
                                                const VkVideoDecodeH265DpbSlotInfoEXT* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_memory_overallocation_behavior
void checkEqual_VkDeviceMemoryOverallocationCreateInfoAMD(
    const VkDeviceMemoryOverallocationCreateInfoAMD* a,
    const VkDeviceMemoryOverallocationCreateInfoAMD* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_vertex_attribute_divisor
void checkEqual_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* a,
    const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVertexInputBindingDivisorDescriptionEXT(
    const VkVertexInputBindingDivisorDescriptionEXT* a,
    const VkVertexInputBindingDivisorDescriptionEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineVertexInputDivisorStateCreateInfoEXT(
    const VkPipelineVertexInputDivisorStateCreateInfoEXT* a,
    const VkPipelineVertexInputDivisorStateCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(
    const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* a,
    const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_GGP_frame_token
void checkEqual_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* a,
                                       const VkPresentFrameTokenGGP* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_pipeline_creation_feedback
void checkEqual_VkPipelineCreationFeedbackEXT(const VkPipelineCreationFeedbackEXT* a,
                                              const VkPipelineCreationFeedbackEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkPipelineCreationFeedbackCreateInfoEXT(
    const VkPipelineCreationFeedbackCreateInfoEXT* a,
    const VkPipelineCreationFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_compute_shader_derivatives
void checkEqual_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* a,
    const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_mesh_shader
void checkEqual_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV* a,
                                                     const VkPhysicalDeviceMeshShaderFeaturesNV* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMeshShaderPropertiesNV(
    const VkPhysicalDeviceMeshShaderPropertiesNV* a,
    const VkPhysicalDeviceMeshShaderPropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkDrawMeshTasksIndirectCommandNV(const VkDrawMeshTasksIndirectCommandNV* a,
                                                 const VkDrawMeshTasksIndirectCommandNV* b,
                                                 OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_fragment_shader_barycentric
void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* a,
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_shader_image_footprint
void checkEqual_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
    const VkPhysicalDeviceShaderImageFootprintFeaturesNV* a,
    const VkPhysicalDeviceShaderImageFootprintFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_scissor_exclusive
void checkEqual_VkPipelineViewportExclusiveScissorStateCreateInfoNV(
    const VkPipelineViewportExclusiveScissorStateCreateInfoNV* a,
    const VkPipelineViewportExclusiveScissorStateCreateInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceExclusiveScissorFeaturesNV(
    const VkPhysicalDeviceExclusiveScissorFeaturesNV* a,
    const VkPhysicalDeviceExclusiveScissorFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void checkEqual_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV* a,
                                                    const VkQueueFamilyCheckpointPropertiesNV* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkCheckpointDataNV(const VkCheckpointDataNV* a, const VkCheckpointDataNV* b,
                                   OnFailCompareFunc onFail);

#endif
#ifdef VK_INTEL_shader_integer_functions2
void checkEqual_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(
    const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* a,
    const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_INTEL_performance_query
void checkEqual_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* a,
                                            const VkPerformanceValueDataINTEL* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkPerformanceValueINTEL(const VkPerformanceValueINTEL* a,
                                        const VkPerformanceValueINTEL* b, OnFailCompareFunc onFail);

void checkEqual_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL* a,
                                                    const VkInitializePerformanceApiInfoINTEL* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkQueryPoolPerformanceQueryCreateInfoINTEL(
    const VkQueryPoolPerformanceQueryCreateInfoINTEL* a,
    const VkQueryPoolPerformanceQueryCreateInfoINTEL* b, OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkQueryPoolPerformanceQueryCreateInfoINTEL,
                      checkEqual_VkQueryPoolCreateInfoINTEL)

void checkEqual_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* a,
                                             const VkPerformanceMarkerInfoINTEL* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL* a,
                                                   const VkPerformanceStreamMarkerInfoINTEL* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* a,
                                               const VkPerformanceOverrideInfoINTEL* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkPerformanceConfigurationAcquireInfoINTEL(
    const VkPerformanceConfigurationAcquireInfoINTEL* a,
    const VkPerformanceConfigurationAcquireInfoINTEL* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_pci_bus_info
void checkEqual_VkPhysicalDevicePCIBusInfoPropertiesEXT(
    const VkPhysicalDevicePCIBusInfoPropertiesEXT* a,
    const VkPhysicalDevicePCIBusInfoPropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_display_native_hdr
void checkEqual_VkDisplayNativeHdrSurfaceCapabilitiesAMD(
    const VkDisplayNativeHdrSurfaceCapabilitiesAMD* a,
    const VkDisplayNativeHdrSurfaceCapabilitiesAMD* b, OnFailCompareFunc onFail);

void checkEqual_VkSwapchainDisplayNativeHdrCreateInfoAMD(
    const VkSwapchainDisplayNativeHdrCreateInfoAMD* a,
    const VkSwapchainDisplayNativeHdrCreateInfoAMD* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_FUCHSIA_imagepipe_surface
void checkEqual_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* a,
                                                    const VkImagePipeSurfaceCreateInfoFUCHSIA* b,
                                                    OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_metal_surface
void checkEqual_VkMetalSurfaceCreateInfoEXT(const VkMetalSurfaceCreateInfoEXT* a,
                                            const VkMetalSurfaceCreateInfoEXT* b,
                                            OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_fragment_density_map
void checkEqual_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(
    const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* a,
    const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(
    const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* a,
    const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkRenderPassFragmentDensityMapCreateInfoEXT(
    const VkRenderPassFragmentDensityMapCreateInfoEXT* a,
    const VkRenderPassFragmentDensityMapCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_scalar_block_layout
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceScalarBlockLayoutFeatures,
                      checkEqual_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT)

#endif
#ifdef VK_GOOGLE_hlsl_functionality1
#endif
#ifdef VK_GOOGLE_decorate_string
#endif
#ifdef VK_EXT_subgroup_size_control
void checkEqual_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* a,
    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* a,
    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* a,
    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_shader_core_properties2
void checkEqual_VkPhysicalDeviceShaderCoreProperties2AMD(
    const VkPhysicalDeviceShaderCoreProperties2AMD* a,
    const VkPhysicalDeviceShaderCoreProperties2AMD* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_device_coherent_memory
void checkEqual_VkPhysicalDeviceCoherentMemoryFeaturesAMD(
    const VkPhysicalDeviceCoherentMemoryFeaturesAMD* a,
    const VkPhysicalDeviceCoherentMemoryFeaturesAMD* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_image_atomic_int64
void checkEqual_VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT(
    const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* a,
    const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_memory_budget
void checkEqual_VkPhysicalDeviceMemoryBudgetPropertiesEXT(
    const VkPhysicalDeviceMemoryBudgetPropertiesEXT* a,
    const VkPhysicalDeviceMemoryBudgetPropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_memory_priority
void checkEqual_VkPhysicalDeviceMemoryPriorityFeaturesEXT(
    const VkPhysicalDeviceMemoryPriorityFeaturesEXT* a,
    const VkPhysicalDeviceMemoryPriorityFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* a,
                                                const VkMemoryPriorityAllocateInfoEXT* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_dedicated_allocation_image_aliasing
void checkEqual_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(
    const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* a,
    const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_buffer_device_address
void checkEqual_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(
    const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* a,
    const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* b, OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT,
                      checkEqual_VkPhysicalDeviceBufferAddressFeaturesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferDeviceAddressInfo, checkEqual_VkBufferDeviceAddressInfoEXT)

void checkEqual_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT* a,
                                                   const VkBufferDeviceAddressCreateInfoEXT* b,
                                                   OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_tooling_info
void checkEqual_VkPhysicalDeviceToolPropertiesEXT(const VkPhysicalDeviceToolPropertiesEXT* a,
                                                  const VkPhysicalDeviceToolPropertiesEXT* b,
                                                  OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_separate_stencil_usage
DEFINE_ALIAS_FUNCTION(checkEqual_VkImageStencilUsageCreateInfo,
                      checkEqual_VkImageStencilUsageCreateInfoEXT)

#endif
#ifdef VK_EXT_validation_features
void checkEqual_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* a,
                                        const VkValidationFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_cooperative_matrix
void checkEqual_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* a,
                                                const VkCooperativeMatrixPropertiesNV* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceCooperativeMatrixFeaturesNV(
    const VkPhysicalDeviceCooperativeMatrixFeaturesNV* a,
    const VkPhysicalDeviceCooperativeMatrixFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceCooperativeMatrixPropertiesNV(
    const VkPhysicalDeviceCooperativeMatrixPropertiesNV* a,
    const VkPhysicalDeviceCooperativeMatrixPropertiesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_coverage_reduction_mode
void checkEqual_VkPhysicalDeviceCoverageReductionModeFeaturesNV(
    const VkPhysicalDeviceCoverageReductionModeFeaturesNV* a,
    const VkPhysicalDeviceCoverageReductionModeFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineCoverageReductionStateCreateInfoNV(
    const VkPipelineCoverageReductionStateCreateInfoNV* a,
    const VkPipelineCoverageReductionStateCreateInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkFramebufferMixedSamplesCombinationNV(
    const VkFramebufferMixedSamplesCombinationNV* a,
    const VkFramebufferMixedSamplesCombinationNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_fragment_shader_interlock
void checkEqual_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(
    const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* a,
    const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_ycbcr_image_arrays
void checkEqual_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(
    const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* a,
    const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_provoking_vertex
void checkEqual_VkPhysicalDeviceProvokingVertexFeaturesEXT(
    const VkPhysicalDeviceProvokingVertexFeaturesEXT* a,
    const VkPhysicalDeviceProvokingVertexFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceProvokingVertexPropertiesEXT(
    const VkPhysicalDeviceProvokingVertexPropertiesEXT* a,
    const VkPhysicalDeviceProvokingVertexPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineRasterizationProvokingVertexStateCreateInfoEXT(
    const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* a,
    const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_full_screen_exclusive
void checkEqual_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT* a,
                                                    const VkSurfaceFullScreenExclusiveInfoEXT* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkSurfaceCapabilitiesFullScreenExclusiveEXT(
    const VkSurfaceCapabilitiesFullScreenExclusiveEXT* a,
    const VkSurfaceCapabilitiesFullScreenExclusiveEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkSurfaceFullScreenExclusiveWin32InfoEXT(
    const VkSurfaceFullScreenExclusiveWin32InfoEXT* a,
    const VkSurfaceFullScreenExclusiveWin32InfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_headless_surface
void checkEqual_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* a,
                                               const VkHeadlessSurfaceCreateInfoEXT* b,
                                               OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_line_rasterization
void checkEqual_VkPhysicalDeviceLineRasterizationFeaturesEXT(
    const VkPhysicalDeviceLineRasterizationFeaturesEXT* a,
    const VkPhysicalDeviceLineRasterizationFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceLineRasterizationPropertiesEXT(
    const VkPhysicalDeviceLineRasterizationPropertiesEXT* a,
    const VkPhysicalDeviceLineRasterizationPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineRasterizationLineStateCreateInfoEXT(
    const VkPipelineRasterizationLineStateCreateInfoEXT* a,
    const VkPipelineRasterizationLineStateCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_atomic_float
void checkEqual_VkPhysicalDeviceShaderAtomicFloatFeaturesEXT(
    const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* a,
    const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_host_query_reset
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceHostQueryResetFeatures,
                      checkEqual_VkPhysicalDeviceHostQueryResetFeaturesEXT)

#endif
#ifdef VK_EXT_index_type_uint8
void checkEqual_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(
    const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* a,
    const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_extended_dynamic_state
void checkEqual_VkPhysicalDeviceExtendedDynamicStateFeaturesEXT(
    const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* a,
    const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_atomic_float2
void checkEqual_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
    const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* a,
    const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
void checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* a,
    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_device_generated_commands
void checkEqual_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* a,
    const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV(
    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* a,
    const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkGraphicsShaderGroupCreateInfoNV(const VkGraphicsShaderGroupCreateInfoNV* a,
                                                  const VkGraphicsShaderGroupCreateInfoNV* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkGraphicsPipelineShaderGroupsCreateInfoNV(
    const VkGraphicsPipelineShaderGroupsCreateInfoNV* a,
    const VkGraphicsPipelineShaderGroupsCreateInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkBindShaderGroupIndirectCommandNV(const VkBindShaderGroupIndirectCommandNV* a,
                                                   const VkBindShaderGroupIndirectCommandNV* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkBindIndexBufferIndirectCommandNV(const VkBindIndexBufferIndirectCommandNV* a,
                                                   const VkBindIndexBufferIndirectCommandNV* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkBindVertexBufferIndirectCommandNV(const VkBindVertexBufferIndirectCommandNV* a,
                                                    const VkBindVertexBufferIndirectCommandNV* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkSetStateFlagsIndirectCommandNV(const VkSetStateFlagsIndirectCommandNV* a,
                                                 const VkSetStateFlagsIndirectCommandNV* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkIndirectCommandsStreamNV(const VkIndirectCommandsStreamNV* a,
                                           const VkIndirectCommandsStreamNV* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkIndirectCommandsLayoutTokenNV(const VkIndirectCommandsLayoutTokenNV* a,
                                                const VkIndirectCommandsLayoutTokenNV* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkIndirectCommandsLayoutCreateInfoNV(const VkIndirectCommandsLayoutCreateInfoNV* a,
                                                     const VkIndirectCommandsLayoutCreateInfoNV* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkGeneratedCommandsInfoNV(const VkGeneratedCommandsInfoNV* a,
                                          const VkGeneratedCommandsInfoNV* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkGeneratedCommandsMemoryRequirementsInfoNV(
    const VkGeneratedCommandsMemoryRequirementsInfoNV* a,
    const VkGeneratedCommandsMemoryRequirementsInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_inherited_viewport_scissor
void checkEqual_VkPhysicalDeviceInheritedViewportScissorFeaturesNV(
    const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* a,
    const VkPhysicalDeviceInheritedViewportScissorFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferInheritanceViewportScissorInfoNV(
    const VkCommandBufferInheritanceViewportScissorInfoNV* a,
    const VkCommandBufferInheritanceViewportScissorInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_texel_buffer_alignment
void checkEqual_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
    const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* a,
    const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* a,
    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_QCOM_render_pass_transform
void checkEqual_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM* a,
                                                   const VkRenderPassTransformBeginInfoQCOM* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferInheritanceRenderPassTransformInfoQCOM(
    const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* a,
    const VkCommandBufferInheritanceRenderPassTransformInfoQCOM* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_device_memory_report
void checkEqual_VkPhysicalDeviceDeviceMemoryReportFeaturesEXT(
    const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* a,
    const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceMemoryReportCallbackDataEXT(const VkDeviceMemoryReportCallbackDataEXT* a,
                                                    const VkDeviceMemoryReportCallbackDataEXT* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkDeviceDeviceMemoryReportCreateInfoEXT(
    const VkDeviceDeviceMemoryReportCreateInfoEXT* a,
    const VkDeviceDeviceMemoryReportCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_acquire_drm_display
#endif
#ifdef VK_EXT_robustness2
void checkEqual_VkPhysicalDeviceRobustness2FeaturesEXT(
    const VkPhysicalDeviceRobustness2FeaturesEXT* a,
    const VkPhysicalDeviceRobustness2FeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceRobustness2PropertiesEXT(
    const VkPhysicalDeviceRobustness2PropertiesEXT* a,
    const VkPhysicalDeviceRobustness2PropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_custom_border_color
void checkEqual_VkSamplerCustomBorderColorCreateInfoEXT(
    const VkSamplerCustomBorderColorCreateInfoEXT* a,
    const VkSamplerCustomBorderColorCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceCustomBorderColorPropertiesEXT(
    const VkPhysicalDeviceCustomBorderColorPropertiesEXT* a,
    const VkPhysicalDeviceCustomBorderColorPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
    const VkPhysicalDeviceCustomBorderColorFeaturesEXT* a,
    const VkPhysicalDeviceCustomBorderColorFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_GOOGLE_user_type
#endif
#ifdef VK_EXT_private_data
void checkEqual_VkPhysicalDevicePrivateDataFeaturesEXT(
    const VkPhysicalDevicePrivateDataFeaturesEXT* a,
    const VkPhysicalDevicePrivateDataFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDevicePrivateDataCreateInfoEXT(const VkDevicePrivateDataCreateInfoEXT* a,
                                                 const VkDevicePrivateDataCreateInfoEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPrivateDataSlotCreateInfoEXT(const VkPrivateDataSlotCreateInfoEXT* a,
                                               const VkPrivateDataSlotCreateInfoEXT* b,
                                               OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_pipeline_creation_cache_control
void checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* a,
    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_device_diagnostics_config
void checkEqual_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* a,
    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceDiagnosticsConfigCreateInfoNV(
    const VkDeviceDiagnosticsConfigCreateInfoNV* a, const VkDeviceDiagnosticsConfigCreateInfoNV* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_QCOM_render_pass_store_ops
#endif
#ifdef VK_NV_fragment_shading_rate_enums
void checkEqual_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
    const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* a,
    const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV(
    const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* a,
    const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineFragmentShadingRateEnumStateCreateInfoNV(
    const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* a,
    const VkPipelineFragmentShadingRateEnumStateCreateInfoNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_ray_tracing_motion_blur
void checkEqual_VkDeviceOrHostAddressConstKHR(const VkDeviceOrHostAddressConstKHR* a,
                                              const VkDeviceOrHostAddressConstKHR* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureGeometryMotionTrianglesDataNV(
    const VkAccelerationStructureGeometryMotionTrianglesDataNV* a,
    const VkAccelerationStructureGeometryMotionTrianglesDataNV* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureMotionInfoNV(const VkAccelerationStructureMotionInfoNV* a,
                                                    const VkAccelerationStructureMotionInfoNV* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureMatrixMotionInstanceNV(
    const VkAccelerationStructureMatrixMotionInstanceNV* a,
    const VkAccelerationStructureMatrixMotionInstanceNV* b, OnFailCompareFunc onFail);

void checkEqual_VkSRTDataNV(const VkSRTDataNV* a, const VkSRTDataNV* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureSRTMotionInstanceNV(
    const VkAccelerationStructureSRTMotionInstanceNV* a,
    const VkAccelerationStructureSRTMotionInstanceNV* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureMotionInstanceDataNV(
    const VkAccelerationStructureMotionInstanceDataNV* a,
    const VkAccelerationStructureMotionInstanceDataNV* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureMotionInstanceNV(
    const VkAccelerationStructureMotionInstanceNV* a,
    const VkAccelerationStructureMotionInstanceNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceRayTracingMotionBlurFeaturesNV(
    const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* a,
    const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
void checkEqual_VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT(
    const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* a,
    const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_fragment_density_map2
void checkEqual_VkPhysicalDeviceFragmentDensityMap2FeaturesEXT(
    const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* a,
    const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFragmentDensityMap2PropertiesEXT(
    const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* a,
    const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_QCOM_rotated_copy_commands
void checkEqual_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQCOM* a,
                                               const VkCopyCommandTransformInfoQCOM* b,
                                               OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_image_robustness
void checkEqual_VkPhysicalDeviceImageRobustnessFeaturesEXT(
    const VkPhysicalDeviceImageRobustnessFeaturesEXT* a,
    const VkPhysicalDeviceImageRobustnessFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_4444_formats
void checkEqual_VkPhysicalDevice4444FormatsFeaturesEXT(
    const VkPhysicalDevice4444FormatsFeaturesEXT* a,
    const VkPhysicalDevice4444FormatsFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_rgba10x6_formats
void checkEqual_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* a,
    const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_acquire_winrt_display
#endif
#ifdef VK_EXT_directfb_surface
void checkEqual_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfoEXT* a,
                                               const VkDirectFBSurfaceCreateInfoEXT* b,
                                               OnFailCompareFunc onFail);

#endif
#ifdef VK_VALVE_mutable_descriptor_type
void checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* a,
    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* b, OnFailCompareFunc onFail);

void checkEqual_VkMutableDescriptorTypeListVALVE(const VkMutableDescriptorTypeListVALVE* a,
                                                 const VkMutableDescriptorTypeListVALVE* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkMutableDescriptorTypeCreateInfoVALVE(
    const VkMutableDescriptorTypeCreateInfoVALVE* a,
    const VkMutableDescriptorTypeCreateInfoVALVE* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_vertex_input_dynamic_state
void checkEqual_VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT(
    const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* a,
    const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVertexInputBindingDescription2EXT(const VkVertexInputBindingDescription2EXT* a,
                                                    const VkVertexInputBindingDescription2EXT* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkVertexInputAttributeDescription2EXT(
    const VkVertexInputAttributeDescription2EXT* a, const VkVertexInputAttributeDescription2EXT* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_physical_device_drm
void checkEqual_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmPropertiesEXT* a,
                                                 const VkPhysicalDeviceDrmPropertiesEXT* b,
                                                 OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_primitive_topology_list_restart
void checkEqual_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
    const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* a,
    const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_FUCHSIA_external_memory
void checkEqual_VkImportMemoryZirconHandleInfoFUCHSIA(
    const VkImportMemoryZirconHandleInfoFUCHSIA* a, const VkImportMemoryZirconHandleInfoFUCHSIA* b,
    OnFailCompareFunc onFail);

void checkEqual_VkMemoryZirconHandlePropertiesFUCHSIA(
    const VkMemoryZirconHandlePropertiesFUCHSIA* a, const VkMemoryZirconHandlePropertiesFUCHSIA* b,
    OnFailCompareFunc onFail);

void checkEqual_VkMemoryGetZirconHandleInfoFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* a,
                                                   const VkMemoryGetZirconHandleInfoFUCHSIA* b,
                                                   OnFailCompareFunc onFail);

#endif
#ifdef VK_FUCHSIA_external_semaphore
void checkEqual_VkImportSemaphoreZirconHandleInfoFUCHSIA(
    const VkImportSemaphoreZirconHandleInfoFUCHSIA* a,
    const VkImportSemaphoreZirconHandleInfoFUCHSIA* b, OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreGetZirconHandleInfoFUCHSIA(
    const VkSemaphoreGetZirconHandleInfoFUCHSIA* a, const VkSemaphoreGetZirconHandleInfoFUCHSIA* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_FUCHSIA_buffer_collection
void checkEqual_VkBufferCollectionCreateInfoFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA* a,
                                                    const VkBufferCollectionCreateInfoFUCHSIA* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkImportMemoryBufferCollectionFUCHSIA(
    const VkImportMemoryBufferCollectionFUCHSIA* a, const VkImportMemoryBufferCollectionFUCHSIA* b,
    OnFailCompareFunc onFail);

void checkEqual_VkBufferCollectionImageCreateInfoFUCHSIA(
    const VkBufferCollectionImageCreateInfoFUCHSIA* a,
    const VkBufferCollectionImageCreateInfoFUCHSIA* b, OnFailCompareFunc onFail);

void checkEqual_VkBufferCollectionConstraintsInfoFUCHSIA(
    const VkBufferCollectionConstraintsInfoFUCHSIA* a,
    const VkBufferCollectionConstraintsInfoFUCHSIA* b, OnFailCompareFunc onFail);

void checkEqual_VkBufferConstraintsInfoFUCHSIA(const VkBufferConstraintsInfoFUCHSIA* a,
                                               const VkBufferConstraintsInfoFUCHSIA* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkBufferCollectionBufferCreateInfoFUCHSIA(
    const VkBufferCollectionBufferCreateInfoFUCHSIA* a,
    const VkBufferCollectionBufferCreateInfoFUCHSIA* b, OnFailCompareFunc onFail);

void checkEqual_VkSysmemColorSpaceFUCHSIA(const VkSysmemColorSpaceFUCHSIA* a,
                                          const VkSysmemColorSpaceFUCHSIA* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkBufferCollectionPropertiesFUCHSIA(const VkBufferCollectionPropertiesFUCHSIA* a,
                                                    const VkBufferCollectionPropertiesFUCHSIA* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkImageFormatConstraintsInfoFUCHSIA(const VkImageFormatConstraintsInfoFUCHSIA* a,
                                                    const VkImageFormatConstraintsInfoFUCHSIA* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkImageConstraintsInfoFUCHSIA(const VkImageConstraintsInfoFUCHSIA* a,
                                              const VkImageConstraintsInfoFUCHSIA* b,
                                              OnFailCompareFunc onFail);

#endif
#ifdef VK_HUAWEI_subpass_shading
void checkEqual_VkSubpassShadingPipelineCreateInfoHUAWEI(
    const VkSubpassShadingPipelineCreateInfoHUAWEI* a,
    const VkSubpassShadingPipelineCreateInfoHUAWEI* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSubpassShadingFeaturesHUAWEI(
    const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* a,
    const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSubpassShadingPropertiesHUAWEI(
    const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* a,
    const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_HUAWEI_invocation_mask
void checkEqual_VkPhysicalDeviceInvocationMaskFeaturesHUAWEI(
    const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* a,
    const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_external_memory_rdma
void checkEqual_VkMemoryGetRemoteAddressInfoNV(const VkMemoryGetRemoteAddressInfoNV* a,
                                               const VkMemoryGetRemoteAddressInfoNV* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
    const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* a,
    const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_extended_dynamic_state2
void checkEqual_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
    const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* a,
    const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_QNX_screen_surface
void checkEqual_VkScreenSurfaceCreateInfoQNX(const VkScreenSurfaceCreateInfoQNX* a,
                                             const VkScreenSurfaceCreateInfoQNX* b,
                                             OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_color_write_enable
void checkEqual_VkPhysicalDeviceColorWriteEnableFeaturesEXT(
    const VkPhysicalDeviceColorWriteEnableFeaturesEXT* a,
    const VkPhysicalDeviceColorWriteEnableFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCreateInfoEXT* a,
                                                  const VkPipelineColorWriteCreateInfoEXT* b,
                                                  OnFailCompareFunc onFail);

#endif
#ifdef VK_GOOGLE_gfxstream
void checkEqual_VkImportColorBufferGOOGLE(const VkImportColorBufferGOOGLE* a,
                                          const VkImportColorBufferGOOGLE* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkImportBufferGOOGLE(const VkImportBufferGOOGLE* a, const VkImportBufferGOOGLE* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkCreateBlobGOOGLE(const VkCreateBlobGOOGLE* a, const VkCreateBlobGOOGLE* b,
                                   OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_global_priority_query
void checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* a,
    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkQueueFamilyGlobalPriorityPropertiesEXT(
    const VkQueueFamilyGlobalPriorityPropertiesEXT* a,
    const VkQueueFamilyGlobalPriorityPropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_multi_draw
void checkEqual_VkPhysicalDeviceMultiDrawFeaturesEXT(const VkPhysicalDeviceMultiDrawFeaturesEXT* a,
                                                     const VkPhysicalDeviceMultiDrawFeaturesEXT* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMultiDrawPropertiesEXT(
    const VkPhysicalDeviceMultiDrawPropertiesEXT* a,
    const VkPhysicalDeviceMultiDrawPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkMultiDrawInfoEXT(const VkMultiDrawInfoEXT* a, const VkMultiDrawInfoEXT* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkMultiDrawIndexedInfoEXT(const VkMultiDrawIndexedInfoEXT* a,
                                          const VkMultiDrawIndexedInfoEXT* b,
                                          OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_border_color_swizzle
void checkEqual_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
    const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* a,
    const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkSamplerBorderColorComponentMappingCreateInfoEXT(
    const VkSamplerBorderColorComponentMappingCreateInfoEXT* a,
    const VkSamplerBorderColorComponentMappingCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_pageable_device_local_memory
void checkEqual_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
    const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* a,
    const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_acceleration_structure
void checkEqual_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* a,
                                         const VkDeviceOrHostAddressKHR* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureBuildRangeInfoKHR(
    const VkAccelerationStructureBuildRangeInfoKHR* a,
    const VkAccelerationStructureBuildRangeInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureGeometryTrianglesDataKHR(
    const VkAccelerationStructureGeometryTrianglesDataKHR* a,
    const VkAccelerationStructureGeometryTrianglesDataKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureGeometryAabbsDataKHR(
    const VkAccelerationStructureGeometryAabbsDataKHR* a,
    const VkAccelerationStructureGeometryAabbsDataKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureGeometryInstancesDataKHR(
    const VkAccelerationStructureGeometryInstancesDataKHR* a,
    const VkAccelerationStructureGeometryInstancesDataKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureGeometryDataKHR(
    const VkAccelerationStructureGeometryDataKHR* a,
    const VkAccelerationStructureGeometryDataKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureGeometryKHR(const VkAccelerationStructureGeometryKHR* a,
                                                   const VkAccelerationStructureGeometryKHR* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureBuildGeometryInfoKHR(
    const VkAccelerationStructureBuildGeometryInfoKHR* a,
    const VkAccelerationStructureBuildGeometryInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureCreateInfoKHR(const VkAccelerationStructureCreateInfoKHR* a,
                                                     const VkAccelerationStructureCreateInfoKHR* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkWriteDescriptorSetAccelerationStructureKHR(
    const VkWriteDescriptorSetAccelerationStructureKHR* a,
    const VkWriteDescriptorSetAccelerationStructureKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceAccelerationStructureFeaturesKHR(
    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* a,
    const VkPhysicalDeviceAccelerationStructureFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceAccelerationStructurePropertiesKHR(
    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* a,
    const VkPhysicalDeviceAccelerationStructurePropertiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureDeviceAddressInfoKHR(
    const VkAccelerationStructureDeviceAddressInfoKHR* a,
    const VkAccelerationStructureDeviceAddressInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureVersionInfoKHR(
    const VkAccelerationStructureVersionInfoKHR* a, const VkAccelerationStructureVersionInfoKHR* b,
    OnFailCompareFunc onFail);

void checkEqual_VkCopyAccelerationStructureToMemoryInfoKHR(
    const VkCopyAccelerationStructureToMemoryInfoKHR* a,
    const VkCopyAccelerationStructureToMemoryInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkCopyMemoryToAccelerationStructureInfoKHR(
    const VkCopyMemoryToAccelerationStructureInfoKHR* a,
    const VkCopyMemoryToAccelerationStructureInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkCopyAccelerationStructureInfoKHR(const VkCopyAccelerationStructureInfoKHR* a,
                                                   const VkCopyAccelerationStructureInfoKHR* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureBuildSizesInfoKHR(
    const VkAccelerationStructureBuildSizesInfoKHR* a,
    const VkAccelerationStructureBuildSizesInfoKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_ray_tracing_pipeline
void checkEqual_VkRayTracingShaderGroupCreateInfoKHR(const VkRayTracingShaderGroupCreateInfoKHR* a,
                                                     const VkRayTracingShaderGroupCreateInfoKHR* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkRayTracingPipelineInterfaceCreateInfoKHR(
    const VkRayTracingPipelineInterfaceCreateInfoKHR* a,
    const VkRayTracingPipelineInterfaceCreateInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkRayTracingPipelineCreateInfoKHR(const VkRayTracingPipelineCreateInfoKHR* a,
                                                  const VkRayTracingPipelineCreateInfoKHR* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceRayTracingPipelineFeaturesKHR(
    const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* a,
    const VkPhysicalDeviceRayTracingPipelineFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceRayTracingPipelinePropertiesKHR(
    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* a,
    const VkPhysicalDeviceRayTracingPipelinePropertiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkStridedDeviceAddressRegionKHR(const VkStridedDeviceAddressRegionKHR* a,
                                                const VkStridedDeviceAddressRegionKHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkTraceRaysIndirectCommandKHR(const VkTraceRaysIndirectCommandKHR* a,
                                              const VkTraceRaysIndirectCommandKHR* b,
                                              OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_ray_query
void checkEqual_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQueryFeaturesKHR* a,
                                                    const VkPhysicalDeviceRayQueryFeaturesKHR* b,
                                                    OnFailCompareFunc onFail);

#endif

}  // namespace vk
}  // namespace gfxstream