path: root/stream-servers/vulkan/cereal/common/goldfish_vk_testing.h

// 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 codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o 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_VERSION_1_3
void checkEqual_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features* a,
                                                 const VkPhysicalDeviceVulkan13Features* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties* a,
                                                   const VkPhysicalDeviceVulkan13Properties* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkPipelineCreationFeedback(const VkPipelineCreationFeedback* a,
                                           const VkPipelineCreationFeedback* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo* a,
                                                     const VkPipelineCreationFeedbackCreateInfo* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeatures(
    const VkPhysicalDeviceShaderTerminateInvocationFeatures* a,
    const VkPhysicalDeviceShaderTerminateInvocationFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties* a,
                                               const VkPhysicalDeviceToolProperties* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* a,
    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures* a,
                                                    const VkPhysicalDevicePrivateDataFeatures* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo* a,
                                              const VkDevicePrivateDataCreateInfo* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo* a,
                                            const VkPrivateDataSlotCreateInfo* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeatures(
    const VkPhysicalDevicePipelineCreationCacheControlFeatures* a,
    const VkPhysicalDevicePipelineCreationCacheControlFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkMemoryBarrier2(const VkMemoryBarrier2* a, const VkMemoryBarrier2* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2* a,
                                       const VkBufferMemoryBarrier2* b, OnFailCompareFunc onFail);

void checkEqual_VkImageMemoryBarrier2(const VkImageMemoryBarrier2* a,
                                      const VkImageMemoryBarrier2* b, OnFailCompareFunc onFail);

void checkEqual_VkDependencyInfo(const VkDependencyInfo* a, const VkDependencyInfo* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo* a,
                                      const VkSemaphoreSubmitInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo* a,
                                          const VkCommandBufferSubmitInfo* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkSubmitInfo2(const VkSubmitInfo2* a, const VkSubmitInfo2* b,
                              OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSynchronization2Features(
    const VkPhysicalDeviceSynchronization2Features* a,
    const VkPhysicalDeviceSynchronization2Features* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* a,
    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceImageRobustnessFeatures(
    const VkPhysicalDeviceImageRobustnessFeatures* a,
    const VkPhysicalDeviceImageRobustnessFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkBufferCopy2(const VkBufferCopy2* a, const VkBufferCopy2* b,
                              OnFailCompareFunc onFail);

void checkEqual_VkCopyBufferInfo2(const VkCopyBufferInfo2* a, const VkCopyBufferInfo2* b,
                                  OnFailCompareFunc onFail);

void checkEqual_VkImageCopy2(const VkImageCopy2* a, const VkImageCopy2* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkCopyImageInfo2(const VkCopyImageInfo2* a, const VkCopyImageInfo2* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkBufferImageCopy2(const VkBufferImageCopy2* a, const VkBufferImageCopy2* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2* a,
                                         const VkCopyBufferToImageInfo2* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2* a,
                                         const VkCopyImageToBufferInfo2* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkImageBlit2(const VkImageBlit2* a, const VkImageBlit2* b,
                             OnFailCompareFunc onFail);

void checkEqual_VkBlitImageInfo2(const VkBlitImageInfo2* a, const VkBlitImageInfo2* b,
                                 OnFailCompareFunc onFail);

void checkEqual_VkImageResolve2(const VkImageResolve2* a, const VkImageResolve2* b,
                                OnFailCompareFunc onFail);

void checkEqual_VkResolveImageInfo2(const VkResolveImageInfo2* a, const VkResolveImageInfo2* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSubgroupSizeControlFeatures(
    const VkPhysicalDeviceSubgroupSizeControlFeatures* a,
    const VkPhysicalDeviceSubgroupSizeControlFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceSubgroupSizeControlProperties(
    const VkPhysicalDeviceSubgroupSizeControlProperties* a,
    const VkPhysicalDeviceSubgroupSizeControlProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* a,
    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceInlineUniformBlockFeatures(
    const VkPhysicalDeviceInlineUniformBlockFeatures* a,
    const VkPhysicalDeviceInlineUniformBlockFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceInlineUniformBlockProperties(
    const VkPhysicalDeviceInlineUniformBlockProperties* a,
    const VkPhysicalDeviceInlineUniformBlockProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkWriteDescriptorSetInlineUniformBlock(
    const VkWriteDescriptorSetInlineUniformBlock* a,
    const VkWriteDescriptorSetInlineUniformBlock* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfo(
    const VkDescriptorPoolInlineUniformBlockCreateInfo* a,
    const VkDescriptorPoolInlineUniformBlockCreateInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* a,
    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo* a,
                                          const VkRenderingAttachmentInfo* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkRenderingInfo(const VkRenderingInfo* a, const VkRenderingInfo* b,
                                OnFailCompareFunc onFail);

void checkEqual_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo* a,
                                              const VkPipelineRenderingCreateInfo* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDynamicRenderingFeatures(
    const VkPhysicalDeviceDynamicRenderingFeatures* a,
    const VkPhysicalDeviceDynamicRenderingFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkCommandBufferInheritanceRenderingInfo(
    const VkCommandBufferInheritanceRenderingInfo* a,
    const VkCommandBufferInheritanceRenderingInfo* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeatures(
    const VkPhysicalDeviceShaderIntegerDotProductFeatures* a,
    const VkPhysicalDeviceShaderIntegerDotProductFeatures* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderIntegerDotProductProperties(
    const VkPhysicalDeviceShaderIntegerDotProductProperties* a,
    const VkPhysicalDeviceShaderIntegerDotProductProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceTexelBufferAlignmentProperties(
    const VkPhysicalDeviceTexelBufferAlignmentProperties* a,
    const VkPhysicalDeviceTexelBufferAlignmentProperties* b, OnFailCompareFunc onFail);

void checkEqual_VkFormatProperties3(const VkFormatProperties3* a, const VkFormatProperties3* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features* a,
                                                     const VkPhysicalDeviceMaintenance4Features* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMaintenance4Properties(
    const VkPhysicalDeviceMaintenance4Properties* a,
    const VkPhysicalDeviceMaintenance4Properties* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* a,
                                                 const VkDeviceBufferMemoryRequirements* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* a,
                                                const VkDeviceImageMemoryRequirements* 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_VkQueueFamilyQueryResultStatusPropertiesKHR(
    const VkQueueFamilyQueryResultStatusPropertiesKHR* a,
    const VkQueueFamilyQueryResultStatusPropertiesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* a,
                                                const VkQueueFamilyVideoPropertiesKHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR* a,
                                      const VkVideoProfileInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* a,
                                          const VkVideoProfileListInfoKHR* 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_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* a,
                                              const VkVideoPictureResourceInfoKHR* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* a,
                                            const VkVideoReferenceSlotInfoKHR* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkVideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR* a,
                                                    const VkVideoSessionMemoryRequirementsKHR* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* a,
                                                const VkBindVideoSessionMemoryInfoKHR* 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_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* a,
                                             const VkVideoDecodeCapabilitiesKHR* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* a,
                                          const VkVideoDecodeUsageInfoKHR* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* a, const VkVideoDecodeInfoKHR* b,
                                     OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_video_decode_h264
void checkEqual_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* a,
                                                const VkVideoDecodeH264ProfileInfoKHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* a,
                                                 const VkVideoDecodeH264CapabilitiesKHR* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264SessionParametersAddInfoKHR(
    const VkVideoDecodeH264SessionParametersAddInfoKHR* a,
    const VkVideoDecodeH264SessionParametersAddInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264SessionParametersCreateInfoKHR(
    const VkVideoDecodeH264SessionParametersCreateInfoKHR* a,
    const VkVideoDecodeH264SessionParametersCreateInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* a,
                                                const VkVideoDecodeH264PictureInfoKHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* a,
                                                const VkVideoDecodeH264DpbSlotInfoKHR* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_dynamic_rendering
DEFINE_ALIAS_FUNCTION(checkEqual_VkRenderingInfo, checkEqual_VkRenderingInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkRenderingAttachmentInfo, checkEqual_VkRenderingAttachmentInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineRenderingCreateInfo,
                      checkEqual_VkPipelineRenderingCreateInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceDynamicRenderingFeatures,
                      checkEqual_VkPhysicalDeviceDynamicRenderingFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkCommandBufferInheritanceRenderingInfo,
                      checkEqual_VkCommandBufferInheritanceRenderingInfoKHR)

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_video_decode_h265
void checkEqual_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* a,
                                                const VkVideoDecodeH265ProfileInfoKHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* a,
                                                 const VkVideoDecodeH265CapabilitiesKHR* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265SessionParametersAddInfoKHR(
    const VkVideoDecodeH265SessionParametersAddInfoKHR* a,
    const VkVideoDecodeH265SessionParametersAddInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265SessionParametersCreateInfoKHR(
    const VkVideoDecodeH265SessionParametersCreateInfoKHR* a,
    const VkVideoDecodeH265SessionParametersCreateInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* a,
                                                const VkVideoDecodeH265PictureInfoKHR* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* a,
                                                const VkVideoDecodeH265DpbSlotInfoKHR* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_global_priority
void checkEqual_VkDeviceQueueGlobalPriorityCreateInfoKHR(
    const VkDeviceQueueGlobalPriorityCreateInfoKHR* a,
    const VkDeviceQueueGlobalPriorityCreateInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* a,
    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkQueueFamilyGlobalPriorityPropertiesKHR(
    const VkQueueFamilyGlobalPriorityPropertiesKHR* a,
    const VkQueueFamilyGlobalPriorityPropertiesKHR* 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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeatures,
                      checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)

#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_map_memory2
void checkEqual_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* a, const VkMemoryMapInfoKHR* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* a, const VkMemoryUnmapInfoKHR* b,
                                     OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_shader_integer_dot_product
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeatures,
                      checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderIntegerDotProductProperties,
                      checkEqual_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)

#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_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* a,
                                             const VkVideoEncodeCapabilitiesKHR* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* a,
    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* a,
                                          const VkVideoEncodeUsageInfoKHR* b,
                                          OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR* a,
                                                     const VkVideoEncodeRateControlLayerInfoKHR* b,
                                                     OnFailCompareFunc onFail);

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

#endif
#ifdef VK_KHR_synchronization2
DEFINE_ALIAS_FUNCTION(checkEqual_VkMemoryBarrier2, checkEqual_VkMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferMemoryBarrier2, checkEqual_VkBufferMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImageMemoryBarrier2, checkEqual_VkImageMemoryBarrier2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDependencyInfo, checkEqual_VkDependencyInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSubmitInfo2, checkEqual_VkSubmitInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkSemaphoreSubmitInfo, checkEqual_VkSemaphoreSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkCommandBufferSubmitInfo, checkEqual_VkCommandBufferSubmitInfoKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSynchronization2Features,
                      checkEqual_VkPhysicalDeviceSynchronization2FeaturesKHR)

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_fragment_shader_barycentric
void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* a,
    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* a,
    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* 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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
                      checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)

#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
DEFINE_ALIAS_FUNCTION(checkEqual_VkCopyBufferInfo2, checkEqual_VkCopyBufferInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkCopyImageInfo2, checkEqual_VkCopyImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkCopyBufferToImageInfo2, checkEqual_VkCopyBufferToImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkCopyImageToBufferInfo2, checkEqual_VkCopyImageToBufferInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBlitImageInfo2, checkEqual_VkBlitImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkResolveImageInfo2, checkEqual_VkResolveImageInfo2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferCopy2, checkEqual_VkBufferCopy2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImageCopy2, checkEqual_VkImageCopy2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImageBlit2, checkEqual_VkImageBlit2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferImageCopy2, checkEqual_VkBufferImageCopy2KHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkImageResolve2, checkEqual_VkImageResolve2KHR)

#endif
#ifdef VK_KHR_format_feature_flags2
DEFINE_ALIAS_FUNCTION(checkEqual_VkFormatProperties3, checkEqual_VkFormatProperties3KHR)

#endif
#ifdef VK_KHR_ray_tracing_maintenance1
void checkEqual_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* a,
    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* b, OnFailCompareFunc onFail);

void checkEqual_VkTraceRaysIndirectCommand2KHR(const VkTraceRaysIndirectCommand2KHR* a,
                                               const VkTraceRaysIndirectCommand2KHR* b,
                                               OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_portability_enumeration
#endif
#ifdef VK_KHR_maintenance4
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMaintenance4Features,
                      checkEqual_VkPhysicalDeviceMaintenance4FeaturesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMaintenance4Properties,
                      checkEqual_VkPhysicalDeviceMaintenance4PropertiesKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceBufferMemoryRequirements,
                      checkEqual_VkDeviceBufferMemoryRequirementsKHR)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceImageMemoryRequirements,
                      checkEqual_VkDeviceImageMemoryRequirementsKHR)

#endif
#ifdef VK_KHR_ray_tracing_position_fetch
void checkEqual_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* a,
    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_ANDROID_native_buffer
void checkEqual_VkNativeBufferUsage2ANDROID(const VkNativeBufferUsage2ANDROID* a,
                                            const VkNativeBufferUsage2ANDROID* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkNativeBufferANDROID(const VkNativeBufferANDROID* a,
                                      const VkNativeBufferANDROID* b, OnFailCompareFunc onFail);

void checkEqual_VkSwapchainImageCreateInfoANDROID(const VkSwapchainImageCreateInfoANDROID* a,
                                                  const VkSwapchainImageCreateInfoANDROID* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePresentationPropertiesANDROID(
    const VkPhysicalDevicePresentationPropertiesANDROID* a,
    const VkPhysicalDevicePresentationPropertiesANDROID* 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_VkVideoEncodeH264SessionParametersAddInfoEXT(
    const VkVideoEncodeH264SessionParametersAddInfoEXT* a,
    const VkVideoEncodeH264SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);

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

void checkEqual_VkVideoEncodeH264NaluSliceInfoEXT(const VkVideoEncodeH264NaluSliceInfoEXT* a,
                                                  const VkVideoEncodeH264NaluSliceInfoEXT* b,
                                                  OnFailCompareFunc onFail);

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

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

void checkEqual_VkVideoEncodeH264ProfileInfoEXT(const VkVideoEncodeH264ProfileInfoEXT* a,
                                                const VkVideoEncodeH264ProfileInfoEXT* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264RateControlInfoEXT(const VkVideoEncodeH264RateControlInfoEXT* a,
                                                    const VkVideoEncodeH264RateControlInfoEXT* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264QpEXT(const VkVideoEncodeH264QpEXT* a,
                                       const VkVideoEncodeH264QpEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264FrameSizeEXT(const VkVideoEncodeH264FrameSizeEXT* a,
                                              const VkVideoEncodeH264FrameSizeEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH264RateControlLayerInfoEXT(
    const VkVideoEncodeH264RateControlLayerInfoEXT* a,
    const VkVideoEncodeH264RateControlLayerInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_video_encode_h265
void checkEqual_VkVideoEncodeH265CapabilitiesEXT(const VkVideoEncodeH265CapabilitiesEXT* a,
                                                 const VkVideoEncodeH265CapabilitiesEXT* 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_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* a,
    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* b, OnFailCompareFunc onFail);

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

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

void checkEqual_VkVideoEncodeH265ProfileInfoEXT(const VkVideoEncodeH265ProfileInfoEXT* a,
                                                const VkVideoEncodeH265ProfileInfoEXT* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265RateControlInfoEXT(const VkVideoEncodeH265RateControlInfoEXT* a,
                                                    const VkVideoEncodeH265RateControlInfoEXT* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265QpEXT(const VkVideoEncodeH265QpEXT* a,
                                       const VkVideoEncodeH265QpEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265FrameSizeEXT(const VkVideoEncodeH265FrameSizeEXT* a,
                                              const VkVideoEncodeH265FrameSizeEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkVideoEncodeH265RateControlLayerInfoEXT(
    const VkVideoEncodeH265RateControlLayerInfoEXT* a,
    const VkVideoEncodeH265RateControlLayerInfoEXT* 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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
                      checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)

#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_pipeline_robustness
void checkEqual_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* a,
    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* a,
    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* a,
                                                  const VkPipelineRobustnessCreateInfoEXT* 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_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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceInlineUniformBlockFeatures,
                      checkEqual_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceInlineUniformBlockProperties,
                      checkEqual_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkWriteDescriptorSetInlineUniformBlock,
                      checkEqual_VkWriteDescriptorSetInlineUniformBlockEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfo,
                      checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)

#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
DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceQueueGlobalPriorityCreateInfoKHR,
                      checkEqual_VkDeviceQueueGlobalPriorityCreateInfoEXT)

#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_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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineCreationFeedbackCreateInfo,
                      checkEqual_VkPipelineCreationFeedbackCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineCreationFeedback,
                      checkEqual_VkPipelineCreationFeedbackEXT)

#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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
                      checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)

#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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSubgroupSizeControlFeatures,
                      checkEqual_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSubgroupSizeControlProperties,
                      checkEqual_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
                      checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)

#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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceToolProperties,
                      checkEqual_VkPhysicalDeviceToolPropertiesEXT)

#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_surface_maintenance1
void checkEqual_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* a,
                                        const VkSurfacePresentModeEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkSurfacePresentScalingCapabilitiesEXT(
    const VkSurfacePresentScalingCapabilitiesEXT* a,
    const VkSurfacePresentScalingCapabilitiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkSurfacePresentModeCompatibilityEXT(const VkSurfacePresentModeCompatibilityEXT* a,
                                                     const VkSurfacePresentModeCompatibilityEXT* b,
                                                     OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_swapchain_maintenance1
void checkEqual_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* a,
    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* a,
                                               const VkSwapchainPresentFenceInfoEXT* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkSwapchainPresentModesCreateInfoEXT(const VkSwapchainPresentModesCreateInfoEXT* a,
                                                     const VkSwapchainPresentModesCreateInfoEXT* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* a,
                                              const VkSwapchainPresentModeInfoEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkSwapchainPresentScalingCreateInfoEXT(
    const VkSwapchainPresentScalingCreateInfoEXT* a,
    const VkSwapchainPresentScalingCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* a,
                                                const VkReleaseSwapchainImagesInfoEXT* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
                      checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)

#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);

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceTexelBufferAlignmentProperties,
                      checkEqual_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)

#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_NV_present_barrier
void checkEqual_VkPhysicalDevicePresentBarrierFeaturesNV(
    const VkPhysicalDevicePresentBarrierFeaturesNV* a,
    const VkPhysicalDevicePresentBarrierFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkSurfaceCapabilitiesPresentBarrierNV(
    const VkSurfaceCapabilitiesPresentBarrierNV* a, const VkSurfaceCapabilitiesPresentBarrierNV* b,
    OnFailCompareFunc onFail);

void checkEqual_VkSwapchainPresentBarrierCreateInfoNV(
    const VkSwapchainPresentBarrierCreateInfoNV* a, const VkSwapchainPresentBarrierCreateInfoNV* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_private_data
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDevicePrivateDataFeatures,
                      checkEqual_VkPhysicalDevicePrivateDataFeaturesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkDevicePrivateDataCreateInfo,
                      checkEqual_VkDevicePrivateDataCreateInfoEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkPrivateDataSlotCreateInfo,
                      checkEqual_VkPrivateDataSlotCreateInfoEXT)

#endif
#ifdef VK_EXT_pipeline_creation_cache_control
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeatures,
                      checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)

#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_low_latency
void checkEqual_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* a,
                                           const VkQueryLowLatencySupportNV* b,
                                           OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_metal_objects
void checkEqual_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* a,
                                                 const VkExportMetalObjectCreateInfoEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT* a,
                                            const VkExportMetalObjectsInfoEXT* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT* a,
                                           const VkExportMetalDeviceInfoEXT* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT* a,
                                                 const VkExportMetalCommandQueueInfoEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT* a,
                                           const VkExportMetalBufferInfoEXT* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT* a,
                                           const VkImportMetalBufferInfoEXT* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT* a,
                                            const VkExportMetalTextureInfoEXT* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT* a,
                                            const VkImportMetalTextureInfoEXT* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT* a,
                                              const VkExportMetalIOSurfaceInfoEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT* a,
                                              const VkImportMetalIOSurfaceInfoEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT* a,
                                                const VkExportMetalSharedEventInfoEXT* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT* a,
                                                const VkImportMetalSharedEventInfoEXT* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_descriptor_buffer
void checkEqual_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* a,
    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* a,
    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* a,
    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT* a,
                                           const VkDescriptorAddressInfoEXT* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT* a,
                                                 const VkDescriptorBufferBindingInfoEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* a,
    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorDataEXT(const VkDescriptorDataEXT* a, const VkDescriptorDataEXT* b,
                                    OnFailCompareFunc onFail);

void checkEqual_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* a,
                                       const VkDescriptorGetInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkBufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT* a,
                                                     const VkBufferCaptureDescriptorDataInfoEXT* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT* a,
                                                    const VkImageCaptureDescriptorDataInfoEXT* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkImageViewCaptureDescriptorDataInfoEXT(
    const VkImageViewCaptureDescriptorDataInfoEXT* a,
    const VkImageViewCaptureDescriptorDataInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkSamplerCaptureDescriptorDataInfoEXT(
    const VkSamplerCaptureDescriptorDataInfoEXT* a, const VkSamplerCaptureDescriptorDataInfoEXT* b,
    OnFailCompareFunc onFail);

void checkEqual_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* a,
    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* a,
    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_graphics_pipeline_library
void checkEqual_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* a,
    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* a,
    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkGraphicsPipelineLibraryCreateInfoEXT(
    const VkGraphicsPipelineLibraryCreateInfoEXT* a,
    const VkGraphicsPipelineLibraryCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_AMD_shader_early_and_late_fragment_tests
void checkEqual_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* a,
    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* b, OnFailCompareFunc onFail);

#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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceImageRobustnessFeatures,
                      checkEqual_VkPhysicalDeviceImageRobustnessFeaturesEXT)

#endif
#ifdef VK_EXT_image_compression_control
void checkEqual_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* a,
    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkImageCompressionControlEXT(const VkImageCompressionControlEXT* a,
                                             const VkImageCompressionControlEXT* b,
                                             OnFailCompareFunc onFail);

void checkEqual_VkSubresourceLayout2EXT(const VkSubresourceLayout2EXT* a,
                                        const VkSubresourceLayout2EXT* b, OnFailCompareFunc onFail);

void checkEqual_VkImageSubresource2EXT(const VkImageSubresource2EXT* a,
                                       const VkImageSubresource2EXT* b, OnFailCompareFunc onFail);

void checkEqual_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT* a,
                                                const VkImageCompressionPropertiesEXT* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_attachment_feedback_loop_layout
void checkEqual_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* a,
    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* b, OnFailCompareFunc onFail);

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

#endif
#ifdef VK_EXT_device_fault
void checkEqual_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT* a,
                                                 const VkPhysicalDeviceFaultFeaturesEXT* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT* a,
                                       const VkDeviceFaultCountsEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceFaultAddressInfoEXT(const VkDeviceFaultAddressInfoEXT* a,
                                            const VkDeviceFaultAddressInfoEXT* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkDeviceFaultVendorInfoEXT(const VkDeviceFaultVendorInfoEXT* a,
                                           const VkDeviceFaultVendorInfoEXT* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT* a, const VkDeviceFaultInfoEXT* b,
                                     OnFailCompareFunc onFail);

void checkEqual_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* a,
    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_ARM_rasterization_order_attachment_access
void checkEqual_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* a,
    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* b,
    OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
                      checkEqual_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)

#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_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* a,
    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* b, OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
                      checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)

void checkEqual_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT* a,
                                               const VkMutableDescriptorTypeListEXT* b,
                                               OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkMutableDescriptorTypeListEXT,
                      checkEqual_VkMutableDescriptorTypeListVALVE)

void checkEqual_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT* a,
                                                     const VkMutableDescriptorTypeCreateInfoEXT* b,
                                                     OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkMutableDescriptorTypeCreateInfoEXT,
                      checkEqual_VkMutableDescriptorTypeCreateInfoVALVE)

#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_device_address_binding_report
void checkEqual_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* a,
    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDeviceAddressBindingCallbackDataEXT(
    const VkDeviceAddressBindingCallbackDataEXT* a, const VkDeviceAddressBindingCallbackDataEXT* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_depth_clip_control
void checkEqual_VkPhysicalDeviceDepthClipControlFeaturesEXT(
    const VkPhysicalDeviceDepthClipControlFeaturesEXT* a,
    const VkPhysicalDeviceDepthClipControlFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineViewportDepthClipControlCreateInfoEXT(
    const VkPipelineViewportDepthClipControlCreateInfoEXT* a,
    const VkPipelineViewportDepthClipControlCreateInfoEXT* 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_pipeline_properties
DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineInfoKHR, checkEqual_VkPipelineInfoEXT)

void checkEqual_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* a,
                                                  const VkPipelinePropertiesIdentifierEXT* b,
                                                  OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* a,
    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_multisampled_render_to_single_sampled
void checkEqual_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* a,
    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* b,
    OnFailCompareFunc onFail);

void checkEqual_VkSubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT* a,
                                                    const VkSubpassResolvePerformanceQueryEXT* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkMultisampledRenderToSingleSampledInfoEXT(
    const VkMultisampledRenderToSingleSampledInfoEXT* a,
    const VkMultisampledRenderToSingleSampledInfoEXT* 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_EXT_primitives_generated_query
void checkEqual_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* a,
    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* 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
DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
                      checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)

DEFINE_ALIAS_FUNCTION(checkEqual_VkQueueFamilyGlobalPriorityPropertiesKHR,
                      checkEqual_VkQueueFamilyGlobalPriorityPropertiesEXT)

#endif
#ifdef VK_EXT_image_view_min_lod
void checkEqual_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* a,
    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT* a,
                                               const VkImageViewMinLodCreateInfoEXT* 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_image_2d_view_of_3d
void checkEqual_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* a,
    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_tile_image
void checkEqual_VkPhysicalDeviceShaderTileImageFeaturesEXT(
    const VkPhysicalDeviceShaderTileImageFeaturesEXT* a,
    const VkPhysicalDeviceShaderTileImageFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderTileImagePropertiesEXT(
    const VkPhysicalDeviceShaderTileImagePropertiesEXT* a,
    const VkPhysicalDeviceShaderTileImagePropertiesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_opacity_micromap
void checkEqual_VkMicromapUsageEXT(const VkMicromapUsageEXT* a, const VkMicromapUsageEXT* b,
                                   OnFailCompareFunc onFail);

void checkEqual_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* a,
                                         const VkDeviceOrHostAddressKHR* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT* a,
                                       const VkMicromapBuildInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT* a,
                                        const VkMicromapCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* a,
    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* a,
    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT* a,
                                         const VkMicromapVersionInfoEXT* b,
                                         OnFailCompareFunc onFail);

void checkEqual_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT* a,
                                              const VkCopyMicromapToMemoryInfoEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT* a,
                                              const VkCopyMemoryToMicromapInfoEXT* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT* a,
                                      const VkCopyMicromapInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT* a,
                                            const VkMicromapBuildSizesInfoEXT* b,
                                            OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureTrianglesOpacityMicromapEXT(
    const VkAccelerationStructureTrianglesOpacityMicromapEXT* a,
    const VkAccelerationStructureTrianglesOpacityMicromapEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkMicromapTriangleEXT(const VkMicromapTriangleEXT* a,
                                      const VkMicromapTriangleEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_displacement_micromap
void checkEqual_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* a,
    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* a,
    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkAccelerationStructureTrianglesDisplacementMicromapNV(
    const VkAccelerationStructureTrianglesDisplacementMicromapNV* a,
    const VkAccelerationStructureTrianglesDisplacementMicromapNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_HUAWEI_cluster_culling_shader
void checkEqual_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* a,
    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* a,
    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* b, OnFailCompareFunc onFail);

#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_ARM_shader_core_properties
void checkEqual_VkPhysicalDeviceShaderCorePropertiesARM(
    const VkPhysicalDeviceShaderCorePropertiesARM* a,
    const VkPhysicalDeviceShaderCorePropertiesARM* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_image_sliced_view_of_3d
void checkEqual_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* a,
    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT* a,
                                               const VkImageViewSlicedCreateInfoEXT* b,
                                               OnFailCompareFunc onFail);

#endif
#ifdef VK_VALVE_descriptor_set_host_mapping
void checkEqual_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* a,
    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* b, OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE* a,
                                                     const VkDescriptorSetBindingReferenceVALVE* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkDescriptorSetLayoutHostMappingInfoVALVE(
    const VkDescriptorSetLayoutHostMappingInfoVALVE* a,
    const VkDescriptorSetLayoutHostMappingInfoVALVE* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_depth_clamp_zero_one
void checkEqual_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* a,
    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_non_seamless_cube_map
void checkEqual_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* a,
    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_QCOM_fragment_density_map_offset
void checkEqual_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* a,
    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* a,
    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* b, OnFailCompareFunc onFail);

void checkEqual_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* a,
    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_copy_memory_indirect
void checkEqual_VkCopyMemoryIndirectCommandNV(const VkCopyMemoryIndirectCommandNV* a,
                                              const VkCopyMemoryIndirectCommandNV* b,
                                              OnFailCompareFunc onFail);

void checkEqual_VkCopyMemoryToImageIndirectCommandNV(const VkCopyMemoryToImageIndirectCommandNV* a,
                                                     const VkCopyMemoryToImageIndirectCommandNV* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* a,
    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* a,
    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_memory_decompression
void checkEqual_VkDecompressMemoryRegionNV(const VkDecompressMemoryRegionNV* a,
                                           const VkDecompressMemoryRegionNV* b,
                                           OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* a,
    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* a,
    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_linear_color_attachment
void checkEqual_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* a,
    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_GOOGLE_surfaceless_query
#endif
#ifdef VK_EXT_image_compression_control_swapchain
void checkEqual_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* a,
    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_QCOM_image_processing
void checkEqual_VkImageViewSampleWeightCreateInfoQCOM(
    const VkImageViewSampleWeightCreateInfoQCOM* a, const VkImageViewSampleWeightCreateInfoQCOM* b,
    OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceImageProcessingFeaturesQCOM(
    const VkPhysicalDeviceImageProcessingFeaturesQCOM* a,
    const VkPhysicalDeviceImageProcessingFeaturesQCOM* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceImageProcessingPropertiesQCOM(
    const VkPhysicalDeviceImageProcessingPropertiesQCOM* a,
    const VkPhysicalDeviceImageProcessingPropertiesQCOM* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_extended_dynamic_state3
void checkEqual_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* a,
    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* a,
    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkColorBlendEquationEXT(const VkColorBlendEquationEXT* a,
                                        const VkColorBlendEquationEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkColorBlendAdvancedEXT(const VkColorBlendAdvancedEXT* a,
                                        const VkColorBlendAdvancedEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_subpass_merge_feedback
void checkEqual_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* a,
    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT* a,
                                               const VkRenderPassCreationControlEXT* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkRenderPassCreationFeedbackInfoEXT(const VkRenderPassCreationFeedbackInfoEXT* a,
                                                    const VkRenderPassCreationFeedbackInfoEXT* b,
                                                    OnFailCompareFunc onFail);

void checkEqual_VkRenderPassCreationFeedbackCreateInfoEXT(
    const VkRenderPassCreationFeedbackCreateInfoEXT* a,
    const VkRenderPassCreationFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkRenderPassSubpassFeedbackInfoEXT(const VkRenderPassSubpassFeedbackInfoEXT* a,
                                                   const VkRenderPassSubpassFeedbackInfoEXT* b,
                                                   OnFailCompareFunc onFail);

void checkEqual_VkRenderPassSubpassFeedbackCreateInfoEXT(
    const VkRenderPassSubpassFeedbackCreateInfoEXT* a,
    const VkRenderPassSubpassFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_LUNARG_direct_driver_loading
void checkEqual_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG* a,
                                                const VkDirectDriverLoadingInfoLUNARG* b,
                                                OnFailCompareFunc onFail);

void checkEqual_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG* a,
                                                const VkDirectDriverLoadingListLUNARG* b,
                                                OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_module_identifier
void checkEqual_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* a,
    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* a,
    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* a,
    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT* a,
                                            const VkShaderModuleIdentifierEXT* b,
                                            OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_rasterization_order_attachment_access
#endif
#ifdef VK_NV_optical_flow
void checkEqual_VkPhysicalDeviceOpticalFlowFeaturesNV(
    const VkPhysicalDeviceOpticalFlowFeaturesNV* a, const VkPhysicalDeviceOpticalFlowFeaturesNV* b,
    OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceOpticalFlowPropertiesNV(
    const VkPhysicalDeviceOpticalFlowPropertiesNV* a,
    const VkPhysicalDeviceOpticalFlowPropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV* a,
                                               const VkOpticalFlowImageFormatInfoNV* b,
                                               OnFailCompareFunc onFail);

void checkEqual_VkOpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV* a,
                                                     const VkOpticalFlowImageFormatPropertiesNV* b,
                                                     OnFailCompareFunc onFail);

void checkEqual_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV* a,
                                                 const VkOpticalFlowSessionCreateInfoNV* b,
                                                 OnFailCompareFunc onFail);

void checkEqual_VkOpticalFlowSessionCreatePrivateDataInfoNV(
    const VkOpticalFlowSessionCreatePrivateDataInfoNV* a,
    const VkOpticalFlowSessionCreatePrivateDataInfoNV* b, OnFailCompareFunc onFail);

void checkEqual_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV* a,
                                           const VkOpticalFlowExecuteInfoNV* b,
                                           OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_legacy_dithering
void checkEqual_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* a,
    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_pipeline_protected_access
void checkEqual_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* a,
    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_shader_object
void checkEqual_VkPhysicalDeviceShaderObjectFeaturesEXT(
    const VkPhysicalDeviceShaderObjectFeaturesEXT* a,
    const VkPhysicalDeviceShaderObjectFeaturesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderObjectPropertiesEXT(
    const VkPhysicalDeviceShaderObjectPropertiesEXT* a,
    const VkPhysicalDeviceShaderObjectPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT* a,
                                      const VkShaderCreateInfoEXT* b, OnFailCompareFunc onFail);

DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
                      checkEqual_VkShaderRequiredSubgroupSizeCreateInfoEXT)

#endif
#ifdef VK_QCOM_tile_properties
void checkEqual_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* a,
    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* b, OnFailCompareFunc onFail);

void checkEqual_VkTilePropertiesQCOM(const VkTilePropertiesQCOM* a, const VkTilePropertiesQCOM* b,
                                     OnFailCompareFunc onFail);

#endif
#ifdef VK_SEC_amigo_profiling
void checkEqual_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* a,
    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* b, OnFailCompareFunc onFail);

void checkEqual_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC* a,
                                              const VkAmigoProfilingSubmitInfoSEC* b,
                                              OnFailCompareFunc onFail);

#endif
#ifdef VK_QCOM_multiview_per_view_viewports
void checkEqual_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* a,
    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_NV_ray_tracing_invocation_reorder
void checkEqual_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* a,
    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* a,
    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_mutable_descriptor_type
#endif
#ifdef VK_ARM_shader_core_builtins
void checkEqual_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* a,
    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* b, OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* a,
    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_pipeline_library_group_handles
void checkEqual_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* a,
    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_QCOM_multiview_per_view_render_areas
void checkEqual_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* a,
    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* b, OnFailCompareFunc onFail);

void checkEqual_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* a,
    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* b, OnFailCompareFunc onFail);

#endif
#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
void checkEqual_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* a,
    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* b,
    OnFailCompareFunc onFail);

#endif
#ifdef VK_KHR_acceleration_structure
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
#ifdef VK_EXT_mesh_shader
void checkEqual_VkPhysicalDeviceMeshShaderFeaturesEXT(
    const VkPhysicalDeviceMeshShaderFeaturesEXT* a, const VkPhysicalDeviceMeshShaderFeaturesEXT* b,
    OnFailCompareFunc onFail);

void checkEqual_VkPhysicalDeviceMeshShaderPropertiesEXT(
    const VkPhysicalDeviceMeshShaderPropertiesEXT* a,
    const VkPhysicalDeviceMeshShaderPropertiesEXT* b, OnFailCompareFunc onFail);

void checkEqual_VkDrawMeshTasksIndirectCommandEXT(const VkDrawMeshTasksIndirectCommandEXT* a,
                                                  const VkDrawMeshTasksIndirectCommandEXT* b,
                                                  OnFailCompareFunc onFail);

#endif

}  // namespace vk
}  // namespace gfxstream