// This file has been automatically generated. Do NOT edit edit manually, all your changes will be lost when it is regenerated.

#include <cstring>
#include "dispatch_table.hpp"
#include "functions.hpp"
#include "record_list.hpp"
#include "vk_function_ids.h"
namespace vk_capture
{
void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue)
{
    g_dispatchTable.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
    recordVoidFunction(VK_FUNCTION_GET_DEVICE_QUEUE_MWN, device, queueFamilyIndex, queueIndex, pQueue);
}
VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
{
    auto result = g_dispatchTable.QueueSubmit(queue, submitCount, pSubmits, fence);
    recordFunction(VK_FUNCTION_QUEUE_SUBMIT_MWN, result, queue, submitCount, pSubmits, fence);
    return result;
}
VkResult vkQueueWaitIdle(VkQueue queue)
{
    auto result = g_dispatchTable.QueueWaitIdle(queue);
    recordFunction(VK_FUNCTION_QUEUE_WAIT_IDLE_MWN, result, queue);
    return result;
}
VkResult vkDeviceWaitIdle(VkDevice device)
{
    auto result = g_dispatchTable.DeviceWaitIdle(device);
    recordFunction(VK_FUNCTION_DEVICE_WAIT_IDLE_MWN, result, device);
    return result;
}
VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
{
    auto result = g_dispatchTable.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
    recordFunction(VK_FUNCTION_ALLOCATE_MEMORY_MWN, result, device, pAllocateInfo, pAllocator, pMemory);
    return result;
}
void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.FreeMemory(device, memory, pAllocator);
    recordVoidFunction(VK_FUNCTION_FREE_MEMORY_MWN, device, memory, pAllocator);
}
VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData)
{
    auto result = g_dispatchTable.MapMemory(device, memory, offset, size, flags, ppData);
    recordFunction(VK_FUNCTION_MAP_MEMORY_MWN, result, device, memory, offset, size, flags, ppData);
    return result;
}
void vkUnmapMemory(VkDevice device, VkDeviceMemory memory)
{
    g_dispatchTable.UnmapMemory(device, memory);
    recordVoidFunction(VK_FUNCTION_UNMAP_MEMORY_MWN, device, memory);
}
VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
{
    auto result = g_dispatchTable.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
    recordFunction(VK_FUNCTION_FLUSH_MAPPED_MEMORY_RANGES_MWN, result, device, memoryRangeCount, pMemoryRanges);
    return result;
}
VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
{
    auto result = g_dispatchTable.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
    recordFunction(VK_FUNCTION_INVALIDATE_MAPPED_MEMORY_RANGES_MWN, result, device, memoryRangeCount, pMemoryRanges);
    return result;
}
void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
{
    g_dispatchTable.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
    recordVoidFunction(VK_FUNCTION_GET_DEVICE_MEMORY_COMMITMENT_MWN, device, memory, pCommittedMemoryInBytes);
}
void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
{
    g_dispatchTable.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_BUFFER_MEMORY_REQUIREMENTS_MWN, device, buffer, pMemoryRequirements);
}
VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset)
{
    auto result = g_dispatchTable.BindBufferMemory(device, buffer, memory, memoryOffset);
    recordFunction(VK_FUNCTION_BIND_BUFFER_MEMORY_MWN, result, device, buffer, memory, memoryOffset);
    return result;
}
void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
{
    g_dispatchTable.GetImageMemoryRequirements(device, image, pMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_IMAGE_MEMORY_REQUIREMENTS_MWN, device, image, pMemoryRequirements);
}
VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset)
{
    auto result = g_dispatchTable.BindImageMemory(device, image, memory, memoryOffset);
    recordFunction(VK_FUNCTION_BIND_IMAGE_MEMORY_MWN, result, device, image, memory, memoryOffset);
    return result;
}
void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
    g_dispatchTable.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS_MWN, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
{
    auto result = g_dispatchTable.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
    recordFunction(VK_FUNCTION_QUEUE_BIND_SPARSE_MWN, result, queue, bindInfoCount, pBindInfo, fence);
    return result;
}
VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
    auto result = g_dispatchTable.CreateFence(device, pCreateInfo, pAllocator, pFence);
    recordFunction(VK_FUNCTION_CREATE_FENCE_MWN, result, device, pCreateInfo, pAllocator, pFence);
    return result;
}
void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyFence(device, fence, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_FENCE_MWN, device, fence, pAllocator);
}
VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
{
    auto result = g_dispatchTable.ResetFences(device, fenceCount, pFences);
    recordFunction(VK_FUNCTION_RESET_FENCES_MWN, result, device, fenceCount, pFences);
    return result;
}
VkResult vkGetFenceStatus(VkDevice device, VkFence fence)
{
    auto result = g_dispatchTable.GetFenceStatus(device, fence);
    recordFunction(VK_FUNCTION_GET_FENCE_STATUS_MWN, result, device, fence);
    return result;
}
VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
{
    auto result = g_dispatchTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
    recordFunction(VK_FUNCTION_WAIT_FOR_FENCES_MWN, result, device, fenceCount, pFences, waitAll, timeout);
    return result;
}
VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
{
    auto result = g_dispatchTable.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
    recordFunction(VK_FUNCTION_CREATE_SEMAPHORE_MWN, result, device, pCreateInfo, pAllocator, pSemaphore);
    return result;
}
void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroySemaphore(device, semaphore, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_SEMAPHORE_MWN, device, semaphore, pAllocator);
}
VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
{
    auto result = g_dispatchTable.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
    recordFunction(VK_FUNCTION_CREATE_EVENT_MWN, result, device, pCreateInfo, pAllocator, pEvent);
    return result;
}
void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyEvent(device, event, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_EVENT_MWN, device, event, pAllocator);
}
VkResult vkGetEventStatus(VkDevice device, VkEvent event)
{
    auto result = g_dispatchTable.GetEventStatus(device, event);
    recordFunction(VK_FUNCTION_GET_EVENT_STATUS_MWN, result, device, event);
    return result;
}
VkResult vkSetEvent(VkDevice device, VkEvent event)
{
    auto result = g_dispatchTable.SetEvent(device, event);
    recordFunction(VK_FUNCTION_SET_EVENT_MWN, result, device, event);
    return result;
}
VkResult vkResetEvent(VkDevice device, VkEvent event)
{
    auto result = g_dispatchTable.ResetEvent(device, event);
    recordFunction(VK_FUNCTION_RESET_EVENT_MWN, result, device, event);
    return result;
}
VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
{
    auto result = g_dispatchTable.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
    recordFunction(VK_FUNCTION_CREATE_QUERY_POOL_MWN, result, device, pCreateInfo, pAllocator, pQueryPool);
    return result;
}
void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyQueryPool(device, queryPool, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_QUERY_POOL_MWN, device, queryPool, pAllocator);
}
VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
{
    auto result = g_dispatchTable.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
    recordFunction(VK_FUNCTION_GET_QUERY_POOL_RESULTS_MWN, result, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
    return result;
}
void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
{
    g_dispatchTable.ResetQueryPool(device, queryPool, firstQuery, queryCount);
    recordVoidFunction(VK_FUNCTION_RESET_QUERY_POOL_MWN, device, queryPool, firstQuery, queryCount);
}
VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
{
    auto result = g_dispatchTable.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
    recordFunction(VK_FUNCTION_CREATE_BUFFER_MWN, result, device, pCreateInfo, pAllocator, pBuffer);
    return result;
}
void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyBuffer(device, buffer, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_BUFFER_MWN, device, buffer, pAllocator);
}
VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
{
    auto result = g_dispatchTable.CreateBufferView(device, pCreateInfo, pAllocator, pView);
    recordFunction(VK_FUNCTION_CREATE_BUFFER_VIEW_MWN, result, device, pCreateInfo, pAllocator, pView);
    return result;
}
void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyBufferView(device, bufferView, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_BUFFER_VIEW_MWN, device, bufferView, pAllocator);
}
VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
{
    auto result = g_dispatchTable.CreateImage(device, pCreateInfo, pAllocator, pImage);
    recordFunction(VK_FUNCTION_CREATE_IMAGE_MWN, result, device, pCreateInfo, pAllocator, pImage);
    return result;
}
void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyImage(device, image, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_IMAGE_MWN, device, image, pAllocator);
}
void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
{
    g_dispatchTable.GetImageSubresourceLayout(device, image, pSubresource, pLayout);
    recordVoidFunction(VK_FUNCTION_GET_IMAGE_SUBRESOURCE_LAYOUT_MWN, device, image, pSubresource, pLayout);
}
VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
{
    auto result = g_dispatchTable.CreateImageView(device, pCreateInfo, pAllocator, pView);
    recordFunction(VK_FUNCTION_CREATE_IMAGE_VIEW_MWN, result, device, pCreateInfo, pAllocator, pView);
    return result;
}
void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyImageView(device, imageView, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_IMAGE_VIEW_MWN, device, imageView, pAllocator);
}
VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
{
    auto result = g_dispatchTable.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
    recordFunction(VK_FUNCTION_CREATE_SHADER_MODULE_MWN, result, device, pCreateInfo, pAllocator, pShaderModule);
    return result;
}
void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyShaderModule(device, shaderModule, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_SHADER_MODULE_MWN, device, shaderModule, pAllocator);
}
VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
{
    auto result = g_dispatchTable.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
    recordFunction(VK_FUNCTION_CREATE_PIPELINE_CACHE_MWN, result, device, pCreateInfo, pAllocator, pPipelineCache);
    return result;
}
void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyPipelineCache(device, pipelineCache, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_PIPELINE_CACHE_MWN, device, pipelineCache, pAllocator);
}
VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
{
    auto result = g_dispatchTable.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
    recordFunction(VK_FUNCTION_GET_PIPELINE_CACHE_DATA_MWN, result, device, pipelineCache, pDataSize, pData);
    return result;
}
VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
{
    auto result = g_dispatchTable.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
    recordFunction(VK_FUNCTION_MERGE_PIPELINE_CACHES_MWN, result, device, dstCache, srcCacheCount, pSrcCaches);
    return result;
}
VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
    auto result = g_dispatchTable.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    recordFunction(VK_FUNCTION_CREATE_GRAPHICS_PIPELINES_MWN, result, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    return result;
}
VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
    auto result = g_dispatchTable.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    recordFunction(VK_FUNCTION_CREATE_COMPUTE_PIPELINES_MWN, result, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    return result;
}
VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize)
{
    auto result = g_dispatchTable.GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize);
    recordFunction(VK_FUNCTION_GET_DEVICE_SUBPASS_SHADING_MAX_WORKGROUP_SIZE_HUAWEI_MWN, result, device, renderpass, pMaxWorkgroupSize);
    return result;
}
void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyPipeline(device, pipeline, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_PIPELINE_MWN, device, pipeline, pAllocator);
}
VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
{
    auto result = g_dispatchTable.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
    recordFunction(VK_FUNCTION_CREATE_PIPELINE_LAYOUT_MWN, result, device, pCreateInfo, pAllocator, pPipelineLayout);
    return result;
}
void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyPipelineLayout(device, pipelineLayout, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_PIPELINE_LAYOUT_MWN, device, pipelineLayout, pAllocator);
}
VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
{
    auto result = g_dispatchTable.CreateSampler(device, pCreateInfo, pAllocator, pSampler);
    recordFunction(VK_FUNCTION_CREATE_SAMPLER_MWN, result, device, pCreateInfo, pAllocator, pSampler);
    return result;
}
void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroySampler(device, sampler, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_SAMPLER_MWN, device, sampler, pAllocator);
}
VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
{
    auto result = g_dispatchTable.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
    recordFunction(VK_FUNCTION_CREATE_DESCRIPTOR_SET_LAYOUT_MWN, result, device, pCreateInfo, pAllocator, pSetLayout);
    return result;
}
void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_DESCRIPTOR_SET_LAYOUT_MWN, device, descriptorSetLayout, pAllocator);
}
VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
{
    auto result = g_dispatchTable.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
    recordFunction(VK_FUNCTION_CREATE_DESCRIPTOR_POOL_MWN, result, device, pCreateInfo, pAllocator, pDescriptorPool);
    return result;
}
void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyDescriptorPool(device, descriptorPool, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_DESCRIPTOR_POOL_MWN, device, descriptorPool, pAllocator);
}
VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
{
    auto result = g_dispatchTable.ResetDescriptorPool(device, descriptorPool, flags);
    recordFunction(VK_FUNCTION_RESET_DESCRIPTOR_POOL_MWN, result, device, descriptorPool, flags);
    return result;
}
VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
{
    auto result = g_dispatchTable.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
    recordFunction(VK_FUNCTION_ALLOCATE_DESCRIPTOR_SETS_MWN, result, device, pAllocateInfo, pDescriptorSets);
    return result;
}
VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
{
    auto result = g_dispatchTable.FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
    recordFunction(VK_FUNCTION_FREE_DESCRIPTOR_SETS_MWN, result, device, descriptorPool, descriptorSetCount, pDescriptorSets);
    return result;
}
void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
{
    g_dispatchTable.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
    recordVoidFunction(VK_FUNCTION_UPDATE_DESCRIPTOR_SETS_MWN, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
}
VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
{
    auto result = g_dispatchTable.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
    recordFunction(VK_FUNCTION_CREATE_FRAMEBUFFER_MWN, result, device, pCreateInfo, pAllocator, pFramebuffer);
    return result;
}
void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyFramebuffer(device, framebuffer, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_FRAMEBUFFER_MWN, device, framebuffer, pAllocator);
}
VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
    auto result = g_dispatchTable.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
    recordFunction(VK_FUNCTION_CREATE_RENDER_PASS_MWN, result, device, pCreateInfo, pAllocator, pRenderPass);
    return result;
}
void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyRenderPass(device, renderPass, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_RENDER_PASS_MWN, device, renderPass, pAllocator);
}
void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
{
    g_dispatchTable.GetRenderAreaGranularity(device, renderPass, pGranularity);
    recordVoidFunction(VK_FUNCTION_GET_RENDER_AREA_GRANULARITY_MWN, device, renderPass, pGranularity);
}
VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
{
    auto result = g_dispatchTable.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
    recordFunction(VK_FUNCTION_CREATE_COMMAND_POOL_MWN, result, device, pCreateInfo, pAllocator, pCommandPool);
    return result;
}
void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyCommandPool(device, commandPool, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_COMMAND_POOL_MWN, device, commandPool, pAllocator);
}
VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
{
    auto result = g_dispatchTable.ResetCommandPool(device, commandPool, flags);
    recordFunction(VK_FUNCTION_RESET_COMMAND_POOL_MWN, result, device, commandPool, flags);
    return result;
}
VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers)
{
    auto result = g_dispatchTable.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
    recordFunction(VK_FUNCTION_ALLOCATE_COMMAND_BUFFERS_MWN, result, device, pAllocateInfo, pCommandBuffers);
    return result;
}
void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
{
    g_dispatchTable.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
    recordVoidFunction(VK_FUNCTION_FREE_COMMAND_BUFFERS_MWN, device, commandPool, commandBufferCount, pCommandBuffers);
}
VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
{
    auto result = g_dispatchTable.BeginCommandBuffer(commandBuffer, pBeginInfo);
    recordFunction(VK_FUNCTION_BEGIN_COMMAND_BUFFER_MWN, result, commandBuffer, pBeginInfo);
    return result;
}
VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer)
{
    auto result = g_dispatchTable.EndCommandBuffer(commandBuffer);
    recordFunction(VK_FUNCTION_END_COMMAND_BUFFER_MWN, result, commandBuffer);
    return result;
}
VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
{
    auto result = g_dispatchTable.ResetCommandBuffer(commandBuffer, flags);
    recordFunction(VK_FUNCTION_RESET_COMMAND_BUFFER_MWN, result, commandBuffer, flags);
    return result;
}
void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
{
    g_dispatchTable.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_PIPELINE_MWN, commandBuffer, pipelineBindPoint, pipeline);
}
void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
{
    g_dispatchTable.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
    recordVoidFunction(VK_FUNCTION_CMD_SET_VIEWPORT_MWN, commandBuffer, firstViewport, viewportCount, pViewports);
}
void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
{
    g_dispatchTable.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
    recordVoidFunction(VK_FUNCTION_CMD_SET_SCISSOR_MWN, commandBuffer, firstScissor, scissorCount, pScissors);
}
void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
{
    g_dispatchTable.CmdSetLineWidth(commandBuffer, lineWidth);
    recordVoidFunction(VK_FUNCTION_CMD_SET_LINE_WIDTH_MWN, commandBuffer, lineWidth);
}
void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
{
    g_dispatchTable.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_BIAS_MWN, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
{
    g_dispatchTable.CmdSetBlendConstants(commandBuffer, blendConstants);
    recordVoidFunction(VK_FUNCTION_CMD_SET_BLEND_CONSTANTS_MWN, commandBuffer, blendConstants);
}
void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
{
    g_dispatchTable.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_BOUNDS_MWN, commandBuffer, minDepthBounds, maxDepthBounds);
}
void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
{
    g_dispatchTable.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
    recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_COMPARE_MASK_MWN, commandBuffer, faceMask, compareMask);
}
void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
{
    g_dispatchTable.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
    recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_WRITE_MASK_MWN, commandBuffer, faceMask, writeMask);
}
void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
{
    g_dispatchTable.CmdSetStencilReference(commandBuffer, faceMask, reference);
    recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_REFERENCE_MWN, commandBuffer, faceMask, reference);
}
void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
{
    g_dispatchTable.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_DESCRIPTOR_SETS_MWN, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
{
    g_dispatchTable.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_INDEX_BUFFER_MWN, commandBuffer, buffer, offset, indexType);
}
void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
{
    g_dispatchTable.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_VERTEX_BUFFERS_MWN, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}
void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
{
    g_dispatchTable.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_MWN, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
{
    g_dispatchTable.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDEXED_MWN, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride)
{
    g_dispatchTable.CmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_MULTI_EXT_MWN, commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride);
}
void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset)
{
    g_dispatchTable.CmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_MULTI_INDEXED_EXT_MWN, commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset);
}
void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
    g_dispatchTable.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDIRECT_MWN, commandBuffer, buffer, offset, drawCount, stride);
}
void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
    g_dispatchTable.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDEXED_INDIRECT_MWN, commandBuffer, buffer, offset, drawCount, stride);
}
void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
    g_dispatchTable.CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
    recordVoidFunction(VK_FUNCTION_CMD_DISPATCH_MWN, commandBuffer, groupCountX, groupCountY, groupCountZ);
}
void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
{
    g_dispatchTable.CmdDispatchIndirect(commandBuffer, buffer, offset);
    recordVoidFunction(VK_FUNCTION_CMD_DISPATCH_INDIRECT_MWN, commandBuffer, buffer, offset);
}
void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer)
{
    g_dispatchTable.CmdSubpassShadingHUAWEI(commandBuffer);
    recordVoidFunction(VK_FUNCTION_CMD_SUBPASS_SHADING_HUAWEI_MWN, commandBuffer);
}
void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
{
    g_dispatchTable.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_BUFFER_MWN, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
{
    g_dispatchTable.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_IMAGE_MWN, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
{
    g_dispatchTable.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
    recordVoidFunction(VK_FUNCTION_CMD_BLIT_IMAGE_MWN, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
{
    g_dispatchTable.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_BUFFER_TO_IMAGE_MWN, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
{
    g_dispatchTable.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_IMAGE_TO_BUFFER_MWN, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData)
{
    g_dispatchTable.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
    recordVoidFunction(VK_FUNCTION_CMD_UPDATE_BUFFER_MWN, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
{
    g_dispatchTable.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
    recordVoidFunction(VK_FUNCTION_CMD_FILL_BUFFER_MWN, commandBuffer, dstBuffer, dstOffset, size, data);
}
void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
{
    g_dispatchTable.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
    recordVoidFunction(VK_FUNCTION_CMD_CLEAR_COLOR_IMAGE_MWN, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
{
    g_dispatchTable.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
    recordVoidFunction(VK_FUNCTION_CMD_CLEAR_DEPTH_STENCIL_IMAGE_MWN, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
{
    g_dispatchTable.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
    recordVoidFunction(VK_FUNCTION_CMD_CLEAR_ATTACHMENTS_MWN, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
{
    g_dispatchTable.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
    recordVoidFunction(VK_FUNCTION_CMD_RESOLVE_IMAGE_MWN, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
{
    g_dispatchTable.CmdSetEvent(commandBuffer, event, stageMask);
    recordVoidFunction(VK_FUNCTION_CMD_SET_EVENT_MWN, commandBuffer, event, stageMask);
}
void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
{
    g_dispatchTable.CmdResetEvent(commandBuffer, event, stageMask);
    recordVoidFunction(VK_FUNCTION_CMD_RESET_EVENT_MWN, commandBuffer, event, stageMask);
}
void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
{
    g_dispatchTable.CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
    recordVoidFunction(VK_FUNCTION_CMD_WAIT_EVENTS_MWN, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers)
{
    g_dispatchTable.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
    recordVoidFunction(VK_FUNCTION_CMD_PIPELINE_BARRIER_MWN, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags)
{
    g_dispatchTable.CmdBeginQuery(commandBuffer, queryPool, query, flags);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_QUERY_MWN, commandBuffer, queryPool, query, flags);
}
void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query)
{
    g_dispatchTable.CmdEndQuery(commandBuffer, queryPool, query);
    recordVoidFunction(VK_FUNCTION_CMD_END_QUERY_MWN, commandBuffer, queryPool, query);
}
void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
{
    g_dispatchTable.CmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_CONDITIONAL_RENDERING_EXT_MWN, commandBuffer, pConditionalRenderingBegin);
}
void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer)
{
    g_dispatchTable.CmdEndConditionalRenderingEXT(commandBuffer);
    recordVoidFunction(VK_FUNCTION_CMD_END_CONDITIONAL_RENDERING_EXT_MWN, commandBuffer);
}
void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
{
    g_dispatchTable.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
    recordVoidFunction(VK_FUNCTION_CMD_RESET_QUERY_POOL_MWN, commandBuffer, queryPool, firstQuery, queryCount);
}
void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query)
{
    g_dispatchTable.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
    recordVoidFunction(VK_FUNCTION_CMD_WRITE_TIMESTAMP_MWN, commandBuffer, pipelineStage, queryPool, query);
}
void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags)
{
    g_dispatchTable.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_QUERY_POOL_RESULTS_MWN, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
{
    g_dispatchTable.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
    recordVoidFunction(VK_FUNCTION_CMD_PUSH_CONSTANTS_MWN, commandBuffer, layout, stageFlags, offset, size, pValues);
}
void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
{
    g_dispatchTable.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_RENDER_PASS_MWN, commandBuffer, pRenderPassBegin, contents);
}
void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
{
    g_dispatchTable.CmdNextSubpass(commandBuffer, contents);
    recordVoidFunction(VK_FUNCTION_CMD_NEXT_SUBPASS_MWN, commandBuffer, contents);
}
void vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
{
    g_dispatchTable.CmdEndRenderPass(commandBuffer);
    recordVoidFunction(VK_FUNCTION_CMD_END_RENDER_PASS_MWN, commandBuffer);
}
void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers)
{
    g_dispatchTable.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
    recordVoidFunction(VK_FUNCTION_CMD_EXECUTE_COMMANDS_MWN, commandBuffer, commandBufferCount, pCommandBuffers);
}
VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains)
{
    auto result = g_dispatchTable.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
    recordFunction(VK_FUNCTION_CREATE_SHARED_SWAPCHAINS_KHR_MWN, result, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
    return result;
}
VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
{
    auto result = g_dispatchTable.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
    recordFunction(VK_FUNCTION_CREATE_SWAPCHAIN_KHR_MWN, result, device, pCreateInfo, pAllocator, pSwapchain);
    return result;
}
void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroySwapchainKHR(device, swapchain, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_SWAPCHAIN_KHR_MWN, device, swapchain, pAllocator);
}
VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages)
{
    auto result = g_dispatchTable.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
    recordFunction(VK_FUNCTION_GET_SWAPCHAIN_IMAGES_KHR_MWN, result, device, swapchain, pSwapchainImageCount, pSwapchainImages);
    return result;
}
VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex)
{
    auto result = g_dispatchTable.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
    recordFunction(VK_FUNCTION_ACQUIRE_NEXT_IMAGE_KHR_MWN, result, device, swapchain, timeout, semaphore, fence, pImageIndex);
    return result;
}
VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
{
    auto result = g_dispatchTable.QueuePresentKHR(queue, pPresentInfo);
    recordFunction(VK_FUNCTION_QUEUE_PRESENT_KHR_MWN, result, queue, pPresentInfo);
    return result;
}
VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
    auto result = g_dispatchTable.DebugMarkerSetObjectNameEXT(device, pNameInfo);
    recordFunction(VK_FUNCTION_DEBUG_MARKER_SET_OBJECT_NAME_EXT_MWN, result, device, pNameInfo);
    return result;
}
VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
    auto result = g_dispatchTable.DebugMarkerSetObjectTagEXT(device, pTagInfo);
    recordFunction(VK_FUNCTION_DEBUG_MARKER_SET_OBJECT_TAG_EXT_MWN, result, device, pTagInfo);
    return result;
}
void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    g_dispatchTable.CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo);
    recordVoidFunction(VK_FUNCTION_CMD_DEBUG_MARKER_BEGIN_EXT_MWN, commandBuffer, pMarkerInfo);
}
void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer)
{
    g_dispatchTable.CmdDebugMarkerEndEXT(commandBuffer);
    recordVoidFunction(VK_FUNCTION_CMD_DEBUG_MARKER_END_EXT_MWN, commandBuffer);
}
void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    g_dispatchTable.CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo);
    recordVoidFunction(VK_FUNCTION_CMD_DEBUG_MARKER_INSERT_EXT_MWN, commandBuffer, pMarkerInfo);
}
void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
{
    g_dispatchTable.CmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
    recordVoidFunction(VK_FUNCTION_CMD_EXECUTE_GENERATED_COMMANDS_NV_MWN, commandBuffer, isPreprocessed, pGeneratedCommandsInfo);
}
void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo)
{
    g_dispatchTable.CmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo);
    recordVoidFunction(VK_FUNCTION_CMD_PREPROCESS_GENERATED_COMMANDS_NV_MWN, commandBuffer, pGeneratedCommandsInfo);
}
void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex)
{
    g_dispatchTable.CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_PIPELINE_SHADER_GROUP_NV_MWN, commandBuffer, pipelineBindPoint, pipeline, groupIndex);
}
void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    g_dispatchTable.GetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_NV_MWN, device, pInfo, pMemoryRequirements);
}
VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout)
{
    auto result = g_dispatchTable.CreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
    recordFunction(VK_FUNCTION_CREATE_INDIRECT_COMMANDS_LAYOUT_NV_MWN, result, device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
    return result;
}
void vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_INDIRECT_COMMANDS_LAYOUT_NV_MWN, device, indirectCommandsLayout, pAllocator);
}
void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites)
{
    g_dispatchTable.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
    recordVoidFunction(VK_FUNCTION_CMD_PUSH_DESCRIPTOR_SET_KHR_MWN, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
}
void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
{
    g_dispatchTable.TrimCommandPool(device, commandPool, flags);
    recordVoidFunction(VK_FUNCTION_TRIM_COMMAND_POOL_MWN, device, commandPool, flags);
}
VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd)
{
    auto result = g_dispatchTable.GetMemoryFdKHR(device, pGetFdInfo, pFd);
    recordFunction(VK_FUNCTION_GET_MEMORY_FD_KHR_MWN, result, device, pGetFdInfo, pFd);
    return result;
}
VkResult vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties)
{
    auto result = g_dispatchTable.GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
    recordFunction(VK_FUNCTION_GET_MEMORY_FD_PROPERTIES_KHR_MWN, result, device, handleType, fd, pMemoryFdProperties);
    return result;
}
VkResult vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress)
{
    auto result = g_dispatchTable.GetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress);
    recordFunction(VK_FUNCTION_GET_MEMORY_REMOTE_ADDRESS_NV_MWN, result, device, pMemoryGetRemoteAddressInfo, pAddress);
    return result;
}
VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd)
{
    auto result = g_dispatchTable.GetSemaphoreFdKHR(device, pGetFdInfo, pFd);
    recordFunction(VK_FUNCTION_GET_SEMAPHORE_FD_KHR_MWN, result, device, pGetFdInfo, pFd);
    return result;
}
VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
{
    auto result = g_dispatchTable.ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
    recordFunction(VK_FUNCTION_IMPORT_SEMAPHORE_FD_KHR_MWN, result, device, pImportSemaphoreFdInfo);
    return result;
}
VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd)
{
    auto result = g_dispatchTable.GetFenceFdKHR(device, pGetFdInfo, pFd);
    recordFunction(VK_FUNCTION_GET_FENCE_FD_KHR_MWN, result, device, pGetFdInfo, pFd);
    return result;
}
VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
{
    auto result = g_dispatchTable.ImportFenceFdKHR(device, pImportFenceFdInfo);
    recordFunction(VK_FUNCTION_IMPORT_FENCE_FD_KHR_MWN, result, device, pImportFenceFdInfo);
    return result;
}
VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
{
    auto result = g_dispatchTable.DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
    recordFunction(VK_FUNCTION_DISPLAY_POWER_CONTROL_EXT_MWN, result, device, display, pDisplayPowerInfo);
    return result;
}
VkResult vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
    auto result = g_dispatchTable.RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
    recordFunction(VK_FUNCTION_REGISTER_DEVICE_EVENT_EXT_MWN, result, device, pDeviceEventInfo, pAllocator, pFence);
    return result;
}
VkResult vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
{
    auto result = g_dispatchTable.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
    recordFunction(VK_FUNCTION_REGISTER_DISPLAY_EVENT_EXT_MWN, result, device, display, pDisplayEventInfo, pAllocator, pFence);
    return result;
}
VkResult vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue)
{
    auto result = g_dispatchTable.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
    recordFunction(VK_FUNCTION_GET_SWAPCHAIN_COUNTER_EXT_MWN, result, device, swapchain, counter, pCounterValue);
    return result;
}
void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    g_dispatchTable.GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
    recordVoidFunction(VK_FUNCTION_GET_DEVICE_GROUP_PEER_MEMORY_FEATURES_MWN, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}
VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos)
{
    auto result = g_dispatchTable.BindBufferMemory2(device, bindInfoCount, pBindInfos);
    recordFunction(VK_FUNCTION_BIND_BUFFER_MEMORY2_MWN, result, device, bindInfoCount, pBindInfos);
    return result;
}
VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos)
{
    auto result = g_dispatchTable.BindImageMemory2(device, bindInfoCount, pBindInfos);
    recordFunction(VK_FUNCTION_BIND_IMAGE_MEMORY2_MWN, result, device, bindInfoCount, pBindInfos);
    return result;
}
void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask)
{
    g_dispatchTable.CmdSetDeviceMask(commandBuffer, deviceMask);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DEVICE_MASK_MWN, commandBuffer, deviceMask);
}
VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
    auto result = g_dispatchTable.GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
    recordFunction(VK_FUNCTION_GET_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR_MWN, result, device, pDeviceGroupPresentCapabilities);
    return result;
}
VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes)
{
    auto result = g_dispatchTable.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
    recordFunction(VK_FUNCTION_GET_DEVICE_GROUP_SURFACE_PRESENT_MODES_KHR_MWN, result, device, surface, pModes);
    return result;
}
VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex)
{
    auto result = g_dispatchTable.AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
    recordFunction(VK_FUNCTION_ACQUIRE_NEXT_IMAGE2_KHR_MWN, result, device, pAcquireInfo, pImageIndex);
    return result;
}
void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ)
{
    g_dispatchTable.CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
    recordVoidFunction(VK_FUNCTION_CMD_DISPATCH_BASE_MWN, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    auto result = g_dispatchTable.CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
    recordFunction(VK_FUNCTION_CREATE_DESCRIPTOR_UPDATE_TEMPLATE_MWN, result, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
    return result;
}
void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_DESCRIPTOR_UPDATE_TEMPLATE_MWN, device, descriptorUpdateTemplate, pAllocator);
}
void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData)
{
    g_dispatchTable.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
    recordVoidFunction(VK_FUNCTION_UPDATE_DESCRIPTOR_SET_WITH_TEMPLATE_MWN, device, descriptorSet, descriptorUpdateTemplate, pData);
}
void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData)
{
    g_dispatchTable.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
    recordVoidFunction(VK_FUNCTION_CMD_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_KHR_MWN, commandBuffer, descriptorUpdateTemplate, layout, set, pData);
}
void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata)
{
    g_dispatchTable.SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
    recordVoidFunction(VK_FUNCTION_SET_HDR_METADATA_EXT_MWN, device, swapchainCount, pSwapchains, pMetadata);
}
VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain)
{
    auto result = g_dispatchTable.GetSwapchainStatusKHR(device, swapchain);
    recordFunction(VK_FUNCTION_GET_SWAPCHAIN_STATUS_KHR_MWN, result, device, swapchain);
    return result;
}
VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
    auto result = g_dispatchTable.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
    recordFunction(VK_FUNCTION_GET_REFRESH_CYCLE_DURATION_GOOGLE_MWN, result, device, swapchain, pDisplayTimingProperties);
    return result;
}
VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings)
{
    auto result = g_dispatchTable.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
    recordFunction(VK_FUNCTION_GET_PAST_PRESENTATION_TIMING_GOOGLE_MWN, result, device, swapchain, pPresentationTimingCount, pPresentationTimings);
    return result;
}
void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings)
{
    g_dispatchTable.CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings);
    recordVoidFunction(VK_FUNCTION_CMD_SET_VIEWPORT_WSCALING_NV_MWN, commandBuffer, firstViewport, viewportCount, pViewportWScalings);
}
void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles)
{
    g_dispatchTable.CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DISCARD_RECTANGLE_EXT_MWN, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
}
void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
    g_dispatchTable.CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo);
    recordVoidFunction(VK_FUNCTION_CMD_SET_SAMPLE_LOCATIONS_EXT_MWN, commandBuffer, pSampleLocationsInfo);
}
void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    g_dispatchTable.GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_BUFFER_MEMORY_REQUIREMENTS2_MWN, device, pInfo, pMemoryRequirements);
}
void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    g_dispatchTable.GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_IMAGE_MEMORY_REQUIREMENTS2_MWN, device, pInfo, pMemoryRequirements);
}
void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    g_dispatchTable.GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS2_MWN, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
void vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    g_dispatchTable.GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_DEVICE_BUFFER_MEMORY_REQUIREMENTS_MWN, device, pInfo, pMemoryRequirements);
}
void vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements)
{
    g_dispatchTable.GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_DEVICE_IMAGE_MEMORY_REQUIREMENTS_MWN, device, pInfo, pMemoryRequirements);
}
void vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    g_dispatchTable.GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_DEVICE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_MWN, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
{
    auto result = g_dispatchTable.CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
    recordFunction(VK_FUNCTION_CREATE_SAMPLER_YCBCR_CONVERSION_MWN, result, device, pCreateInfo, pAllocator, pYcbcrConversion);
    return result;
}
void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_SAMPLER_YCBCR_CONVERSION_MWN, device, ycbcrConversion, pAllocator);
}
void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue)
{
    g_dispatchTable.GetDeviceQueue2(device, pQueueInfo, pQueue);
    recordVoidFunction(VK_FUNCTION_GET_DEVICE_QUEUE2_MWN, device, pQueueInfo, pQueue);
}
VkResult vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache)
{
    auto result = g_dispatchTable.CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
    recordFunction(VK_FUNCTION_CREATE_VALIDATION_CACHE_EXT_MWN, result, device, pCreateInfo, pAllocator, pValidationCache);
    return result;
}
void vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyValidationCacheEXT(device, validationCache, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_VALIDATION_CACHE_EXT_MWN, device, validationCache, pAllocator);
}
VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData)
{
    auto result = g_dispatchTable.GetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
    recordFunction(VK_FUNCTION_GET_VALIDATION_CACHE_DATA_EXT_MWN, result, device, validationCache, pDataSize, pData);
    return result;
}
VkResult vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches)
{
    auto result = g_dispatchTable.MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
    recordFunction(VK_FUNCTION_MERGE_VALIDATION_CACHES_EXT_MWN, result, device, dstCache, srcCacheCount, pSrcCaches);
    return result;
}
void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
{
    g_dispatchTable.GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
    recordVoidFunction(VK_FUNCTION_GET_DESCRIPTOR_SET_LAYOUT_SUPPORT_MWN, device, pCreateInfo, pSupport);
}
VkResult vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo)
{
    auto result = g_dispatchTable.GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
    recordFunction(VK_FUNCTION_GET_SHADER_INFO_AMD_MWN, result, device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
    return result;
}
void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable)
{
    g_dispatchTable.SetLocalDimmingAMD(device, swapChain, localDimmingEnable);
    recordVoidFunction(VK_FUNCTION_SET_LOCAL_DIMMING_AMD_MWN, device, swapChain, localDimmingEnable);
}
VkResult vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation)
{
    auto result = g_dispatchTable.GetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
    recordFunction(VK_FUNCTION_GET_CALIBRATED_TIMESTAMPS_EXT_MWN, result, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation);
    return result;
}
VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
{
    auto result = g_dispatchTable.SetDebugUtilsObjectNameEXT(device, pNameInfo);
    recordFunction(VK_FUNCTION_SET_DEBUG_UTILS_OBJECT_NAME_EXT_MWN, result, device, pNameInfo);
    return result;
}
VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
{
    auto result = g_dispatchTable.SetDebugUtilsObjectTagEXT(device, pTagInfo);
    recordFunction(VK_FUNCTION_SET_DEBUG_UTILS_OBJECT_TAG_EXT_MWN, result, device, pTagInfo);
    return result;
}
void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
{
    g_dispatchTable.QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo);
    recordVoidFunction(VK_FUNCTION_QUEUE_BEGIN_DEBUG_UTILS_LABEL_EXT_MWN, queue, pLabelInfo);
}
void vkQueueEndDebugUtilsLabelEXT(VkQueue queue)
{
    g_dispatchTable.QueueEndDebugUtilsLabelEXT(queue);
    recordVoidFunction(VK_FUNCTION_QUEUE_END_DEBUG_UTILS_LABEL_EXT_MWN, queue);
}
void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo)
{
    g_dispatchTable.QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo);
    recordVoidFunction(VK_FUNCTION_QUEUE_INSERT_DEBUG_UTILS_LABEL_EXT_MWN, queue, pLabelInfo);
}
void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
{
    g_dispatchTable.CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_DEBUG_UTILS_LABEL_EXT_MWN, commandBuffer, pLabelInfo);
}
void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer)
{
    g_dispatchTable.CmdEndDebugUtilsLabelEXT(commandBuffer);
    recordVoidFunction(VK_FUNCTION_CMD_END_DEBUG_UTILS_LABEL_EXT_MWN, commandBuffer);
}
void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo)
{
    g_dispatchTable.CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo);
    recordVoidFunction(VK_FUNCTION_CMD_INSERT_DEBUG_UTILS_LABEL_EXT_MWN, commandBuffer, pLabelInfo);
}
VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
{
    auto result = g_dispatchTable.GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
    recordFunction(VK_FUNCTION_GET_MEMORY_HOST_POINTER_PROPERTIES_EXT_MWN, result, device, handleType, pHostPointer, pMemoryHostPointerProperties);
    return result;
}
void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
{
    g_dispatchTable.CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
    recordVoidFunction(VK_FUNCTION_CMD_WRITE_BUFFER_MARKER_AMD_MWN, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
}
VkResult vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
{
    auto result = g_dispatchTable.CreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass);
    recordFunction(VK_FUNCTION_CREATE_RENDER_PASS2_MWN, result, device, pCreateInfo, pAllocator, pRenderPass);
    return result;
}
void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo)
{
    g_dispatchTable.CmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_RENDER_PASS2_MWN, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
}
void vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo)
{
    g_dispatchTable.CmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
    recordVoidFunction(VK_FUNCTION_CMD_NEXT_SUBPASS2_MWN, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
}
void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo)
{
    g_dispatchTable.CmdEndRenderPass2(commandBuffer, pSubpassEndInfo);
    recordVoidFunction(VK_FUNCTION_CMD_END_RENDER_PASS2_MWN, commandBuffer, pSubpassEndInfo);
}
VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
{
    auto result = g_dispatchTable.GetSemaphoreCounterValue(device, semaphore, pValue);
    recordFunction(VK_FUNCTION_GET_SEMAPHORE_COUNTER_VALUE_MWN, result, device, semaphore, pValue);
    return result;
}
VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
{
    auto result = g_dispatchTable.WaitSemaphores(device, pWaitInfo, timeout);
    recordFunction(VK_FUNCTION_WAIT_SEMAPHORES_MWN, result, device, pWaitInfo, timeout);
    return result;
}
VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
{
    auto result = g_dispatchTable.SignalSemaphore(device, pSignalInfo);
    recordFunction(VK_FUNCTION_SIGNAL_SEMAPHORE_MWN, result, device, pSignalInfo);
    return result;
}
void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    g_dispatchTable.CmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDIRECT_COUNT_MWN, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    g_dispatchTable.CmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDEXED_INDIRECT_COUNT_MWN, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker)
{
    g_dispatchTable.CmdSetCheckpointNV(commandBuffer, pCheckpointMarker);
    recordVoidFunction(VK_FUNCTION_CMD_SET_CHECKPOINT_NV_MWN, commandBuffer, pCheckpointMarker);
}
void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData)
{
    g_dispatchTable.GetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData);
    recordVoidFunction(VK_FUNCTION_GET_QUEUE_CHECKPOINT_DATA_NV_MWN, queue, pCheckpointDataCount, pCheckpointData);
}
void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes)
{
    g_dispatchTable.CmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_TRANSFORM_FEEDBACK_BUFFERS_EXT_MWN, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
}
void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
{
    g_dispatchTable.CmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_TRANSFORM_FEEDBACK_EXT_MWN, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
}
void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets)
{
    g_dispatchTable.CmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
    recordVoidFunction(VK_FUNCTION_CMD_END_TRANSFORM_FEEDBACK_EXT_MWN, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
}
void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index)
{
    g_dispatchTable.CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_QUERY_INDEXED_EXT_MWN, commandBuffer, queryPool, query, flags, index);
}
void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index)
{
    g_dispatchTable.CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
    recordVoidFunction(VK_FUNCTION_CMD_END_QUERY_INDEXED_EXT_MWN, commandBuffer, queryPool, query, index);
}
void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride)
{
    g_dispatchTable.CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDIRECT_BYTE_COUNT_EXT_MWN, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
}
void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors)
{
    g_dispatchTable.CmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
    recordVoidFunction(VK_FUNCTION_CMD_SET_EXCLUSIVE_SCISSOR_NV_MWN, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
}
void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
{
    g_dispatchTable.CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_SHADING_RATE_IMAGE_NV_MWN, commandBuffer, imageView, imageLayout);
}
void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes)
{
    g_dispatchTable.CmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
    recordVoidFunction(VK_FUNCTION_CMD_SET_VIEWPORT_SHADING_RATE_PALETTE_NV_MWN, commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
}
void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders)
{
    g_dispatchTable.CmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
    recordVoidFunction(VK_FUNCTION_CMD_SET_COARSE_SAMPLE_ORDER_NV_MWN, commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
}
void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask)
{
    g_dispatchTable.CmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_MESH_TASKS_NV_MWN, commandBuffer, taskCount, firstTask);
}
void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
{
    g_dispatchTable.CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_MESH_TASKS_INDIRECT_NV_MWN, commandBuffer, buffer, offset, drawCount, stride);
}
void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)
{
    g_dispatchTable.CmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
    recordVoidFunction(VK_FUNCTION_CMD_DRAW_MESH_TASKS_INDIRECT_COUNT_NV_MWN, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader)
{
    auto result = g_dispatchTable.CompileDeferredNV(device, pipeline, shader);
    recordFunction(VK_FUNCTION_COMPILE_DEFERRED_NV_MWN, result, device, pipeline, shader);
    return result;
}
VkResult vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure)
{
    auto result = g_dispatchTable.CreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
    recordFunction(VK_FUNCTION_CREATE_ACCELERATION_STRUCTURE_NV_MWN, result, device, pCreateInfo, pAllocator, pAccelerationStructure);
    return result;
}
void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout)
{
    g_dispatchTable.CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_INVOCATION_MASK_HUAWEI_MWN, commandBuffer, imageView, imageLayout);
}
void vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_ACCELERATION_STRUCTURE_KHR_MWN, device, accelerationStructure, pAllocator);
}
void vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_ACCELERATION_STRUCTURE_NV_MWN, device, accelerationStructure, pAllocator);
}
void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
{
    g_dispatchTable.GetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
    recordVoidFunction(VK_FUNCTION_GET_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_NV_MWN, device, pInfo, pMemoryRequirements);
}
VkResult vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos)
{
    auto result = g_dispatchTable.BindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
    recordFunction(VK_FUNCTION_BIND_ACCELERATION_STRUCTURE_MEMORY_NV_MWN, result, device, bindInfoCount, pBindInfos);
    return result;
}
void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode)
{
    g_dispatchTable.CmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_NV_MWN, commandBuffer, dst, src, mode);
}
void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo)
{
    g_dispatchTable.CmdCopyAccelerationStructureKHR(commandBuffer, pInfo);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_KHR_MWN, commandBuffer, pInfo);
}
VkResult vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo)
{
    auto result = g_dispatchTable.CopyAccelerationStructureKHR(device, deferredOperation, pInfo);
    recordFunction(VK_FUNCTION_COPY_ACCELERATION_STRUCTURE_KHR_MWN, result, device, deferredOperation, pInfo);
    return result;
}
void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
{
    g_dispatchTable.CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_KHR_MWN, commandBuffer, pInfo);
}
VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo)
{
    auto result = g_dispatchTable.CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo);
    recordFunction(VK_FUNCTION_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_KHR_MWN, result, device, deferredOperation, pInfo);
    return result;
}
void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
{
    g_dispatchTable.CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_KHR_MWN, commandBuffer, pInfo);
}
VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo)
{
    auto result = g_dispatchTable.CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo);
    recordFunction(VK_FUNCTION_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_KHR_MWN, result, device, deferredOperation, pInfo);
    return result;
}
void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
{
    g_dispatchTable.CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
    recordVoidFunction(VK_FUNCTION_CMD_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_KHR_MWN, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
}
void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery)
{
    g_dispatchTable.CmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
    recordVoidFunction(VK_FUNCTION_CMD_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_NV_MWN, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
}
void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset)
{
    g_dispatchTable.CmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
    recordVoidFunction(VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURE_NV_MWN, commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
}
VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride)
{
    auto result = g_dispatchTable.WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
    recordFunction(VK_FUNCTION_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_KHR_MWN, result, device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride);
    return result;
}
void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth)
{
    g_dispatchTable.CmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
    recordVoidFunction(VK_FUNCTION_CMD_TRACE_RAYS_KHR_MWN, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth);
}
void vkCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth)
{
    g_dispatchTable.CmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
    recordVoidFunction(VK_FUNCTION_CMD_TRACE_RAYS_NV_MWN, commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
}
VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
{
    auto result = g_dispatchTable.GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
    recordFunction(VK_FUNCTION_GET_RAY_TRACING_SHADER_GROUP_HANDLES_KHR_MWN, result, device, pipeline, firstGroup, groupCount, dataSize, pData);
    return result;
}
VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData)
{
    auto result = g_dispatchTable.GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData);
    recordFunction(VK_FUNCTION_GET_RAY_TRACING_CAPTURE_REPLAY_SHADER_GROUP_HANDLES_KHR_MWN, result, device, pipeline, firstGroup, groupCount, dataSize, pData);
    return result;
}
VkResult vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData)
{
    auto result = g_dispatchTable.GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
    recordFunction(VK_FUNCTION_GET_ACCELERATION_STRUCTURE_HANDLE_NV_MWN, result, device, accelerationStructure, dataSize, pData);
    return result;
}
VkResult vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
    auto result = g_dispatchTable.CreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    recordFunction(VK_FUNCTION_CREATE_RAY_TRACING_PIPELINES_NV_MWN, result, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    return result;
}
VkResult vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
{
    auto result = g_dispatchTable.CreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    recordFunction(VK_FUNCTION_CREATE_RAY_TRACING_PIPELINES_KHR_MWN, result, device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    return result;
}
void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress)
{
    g_dispatchTable.CmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
    recordVoidFunction(VK_FUNCTION_CMD_TRACE_RAYS_INDIRECT_KHR_MWN, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress);
}
void vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress)
{
    g_dispatchTable.CmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress);
    recordVoidFunction(VK_FUNCTION_CMD_TRACE_RAYS_INDIRECT2_KHR_MWN, commandBuffer, indirectDeviceAddress);
}
void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility)
{
    g_dispatchTable.GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility);
    recordVoidFunction(VK_FUNCTION_GET_DEVICE_ACCELERATION_STRUCTURE_COMPATIBILITY_KHR_MWN, device, pVersionInfo, pCompatibility);
}
VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader)
{
    auto result = g_dispatchTable.GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader);
    recordFunction(VK_FUNCTION_GET_RAY_TRACING_SHADER_GROUP_STACK_SIZE_KHR_MWN, result, device, pipeline, group, groupShader);
    return result;
}
void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize)
{
    g_dispatchTable.CmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize);
    recordVoidFunction(VK_FUNCTION_CMD_SET_RAY_TRACING_PIPELINE_STACK_SIZE_KHR_MWN, commandBuffer, pipelineStackSize);
}
uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo)
{
    auto result = g_dispatchTable.GetImageViewHandleNVX(device, pInfo);
    recordFunction(VK_FUNCTION_GET_IMAGE_VIEW_HANDLE_NVX_MWN, result, device, pInfo);
    return result;
}
VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties)
{
    auto result = g_dispatchTable.GetImageViewAddressNVX(device, imageView, pProperties);
    recordFunction(VK_FUNCTION_GET_IMAGE_VIEW_ADDRESS_NVX_MWN, result, device, imageView, pProperties);
    return result;
}
VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo)
{
    auto result = g_dispatchTable.AcquireProfilingLockKHR(device, pInfo);
    recordFunction(VK_FUNCTION_ACQUIRE_PROFILING_LOCK_KHR_MWN, result, device, pInfo);
    return result;
}
void vkReleaseProfilingLockKHR(VkDevice device)
{
    g_dispatchTable.ReleaseProfilingLockKHR(device);
    recordVoidFunction(VK_FUNCTION_RELEASE_PROFILING_LOCK_KHR_MWN, device);
}
VkResult vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties)
{
    auto result = g_dispatchTable.GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
    recordFunction(VK_FUNCTION_GET_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT_MWN, result, device, image, pProperties);
    return result;
}
uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
    auto result = g_dispatchTable.GetBufferOpaqueCaptureAddress(device, pInfo);
    recordFunction(VK_FUNCTION_GET_BUFFER_OPAQUE_CAPTURE_ADDRESS_MWN, result, device, pInfo);
    return result;
}
VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo)
{
    auto result = g_dispatchTable.GetBufferDeviceAddress(device, pInfo);
    recordFunction(VK_FUNCTION_GET_BUFFER_DEVICE_ADDRESS_MWN, result, device, pInfo);
    return result;
}
VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo)
{
    auto result = g_dispatchTable.InitializePerformanceApiINTEL(device, pInitializeInfo);
    recordFunction(VK_FUNCTION_INITIALIZE_PERFORMANCE_API_INTEL_MWN, result, device, pInitializeInfo);
    return result;
}
void vkUninitializePerformanceApiINTEL(VkDevice device)
{
    g_dispatchTable.UninitializePerformanceApiINTEL(device);
    recordVoidFunction(VK_FUNCTION_UNINITIALIZE_PERFORMANCE_API_INTEL_MWN, device);
}
VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo)
{
    auto result = g_dispatchTable.CmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo);
    recordFunction(VK_FUNCTION_CMD_SET_PERFORMANCE_MARKER_INTEL_MWN, result, commandBuffer, pMarkerInfo);
    return result;
}
VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo)
{
    auto result = g_dispatchTable.CmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo);
    recordFunction(VK_FUNCTION_CMD_SET_PERFORMANCE_STREAM_MARKER_INTEL_MWN, result, commandBuffer, pMarkerInfo);
    return result;
}
VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo)
{
    auto result = g_dispatchTable.CmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo);
    recordFunction(VK_FUNCTION_CMD_SET_PERFORMANCE_OVERRIDE_INTEL_MWN, result, commandBuffer, pOverrideInfo);
    return result;
}
VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration)
{
    auto result = g_dispatchTable.AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
    recordFunction(VK_FUNCTION_ACQUIRE_PERFORMANCE_CONFIGURATION_INTEL_MWN, result, device, pAcquireInfo, pConfiguration);
    return result;
}
VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration)
{
    auto result = g_dispatchTable.ReleasePerformanceConfigurationINTEL(device, configuration);
    recordFunction(VK_FUNCTION_RELEASE_PERFORMANCE_CONFIGURATION_INTEL_MWN, result, device, configuration);
    return result;
}
VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration)
{
    auto result = g_dispatchTable.QueueSetPerformanceConfigurationINTEL(queue, configuration);
    recordFunction(VK_FUNCTION_QUEUE_SET_PERFORMANCE_CONFIGURATION_INTEL_MWN, result, queue, configuration);
    return result;
}
VkResult vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue)
{
    auto result = g_dispatchTable.GetPerformanceParameterINTEL(device, parameter, pValue);
    recordFunction(VK_FUNCTION_GET_PERFORMANCE_PARAMETER_INTEL_MWN, result, device, parameter, pValue);
    return result;
}
uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo)
{
    auto result = g_dispatchTable.GetDeviceMemoryOpaqueCaptureAddress(device, pInfo);
    recordFunction(VK_FUNCTION_GET_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_MWN, result, device, pInfo);
    return result;
}
VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)
{
    auto result = g_dispatchTable.GetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
    recordFunction(VK_FUNCTION_GET_PIPELINE_EXECUTABLE_PROPERTIES_KHR_MWN, result, device, pPipelineInfo, pExecutableCount, pProperties);
    return result;
}
VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics)
{
    auto result = g_dispatchTable.GetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
    recordFunction(VK_FUNCTION_GET_PIPELINE_EXECUTABLE_STATISTICS_KHR_MWN, result, device, pExecutableInfo, pStatisticCount, pStatistics);
    return result;
}
VkResult vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
{
    auto result = g_dispatchTable.GetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
    recordFunction(VK_FUNCTION_GET_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATIONS_KHR_MWN, result, device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
    return result;
}
void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)
{
    g_dispatchTable.CmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
    recordVoidFunction(VK_FUNCTION_CMD_SET_LINE_STIPPLE_EXT_MWN, commandBuffer, lineStippleFactor, lineStipplePattern);
}
VkResult vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure)
{
    auto result = g_dispatchTable.CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure);
    recordFunction(VK_FUNCTION_CREATE_ACCELERATION_STRUCTURE_KHR_MWN, result, device, pCreateInfo, pAllocator, pAccelerationStructure);
    return result;
}
void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
{
    g_dispatchTable.CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
    recordVoidFunction(VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURES_KHR_MWN, commandBuffer, infoCount, pInfos, ppBuildRangeInfos);
}
void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts)
{
    g_dispatchTable.CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
    recordVoidFunction(VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURES_INDIRECT_KHR_MWN, commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts);
}
VkResult vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos)
{
    auto result = g_dispatchTable.BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
    recordFunction(VK_FUNCTION_BUILD_ACCELERATION_STRUCTURES_KHR_MWN, result, device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos);
    return result;
}
VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo)
{
    auto result = g_dispatchTable.GetAccelerationStructureDeviceAddressKHR(device, pInfo);
    recordFunction(VK_FUNCTION_GET_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_KHR_MWN, result, device, pInfo);
    return result;
}
VkResult vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation)
{
    auto result = g_dispatchTable.CreateDeferredOperationKHR(device, pAllocator, pDeferredOperation);
    recordFunction(VK_FUNCTION_CREATE_DEFERRED_OPERATION_KHR_MWN, result, device, pAllocator, pDeferredOperation);
    return result;
}
void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyDeferredOperationKHR(device, operation, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_DEFERRED_OPERATION_KHR_MWN, device, operation, pAllocator);
}
uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation)
{
    auto result = g_dispatchTable.GetDeferredOperationMaxConcurrencyKHR(device, operation);
    recordFunction(VK_FUNCTION_GET_DEFERRED_OPERATION_MAX_CONCURRENCY_KHR_MWN, result, device, operation);
    return result;
}
VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation)
{
    auto result = g_dispatchTable.GetDeferredOperationResultKHR(device, operation);
    recordFunction(VK_FUNCTION_GET_DEFERRED_OPERATION_RESULT_KHR_MWN, result, device, operation);
    return result;
}
VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation)
{
    auto result = g_dispatchTable.DeferredOperationJoinKHR(device, operation);
    recordFunction(VK_FUNCTION_DEFERRED_OPERATION_JOIN_KHR_MWN, result, device, operation);
    return result;
}
void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode)
{
    g_dispatchTable.CmdSetCullMode(commandBuffer, cullMode);
    recordVoidFunction(VK_FUNCTION_CMD_SET_CULL_MODE_MWN, commandBuffer, cullMode);
}
void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace)
{
    g_dispatchTable.CmdSetFrontFace(commandBuffer, frontFace);
    recordVoidFunction(VK_FUNCTION_CMD_SET_FRONT_FACE_MWN, commandBuffer, frontFace);
}
void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology)
{
    g_dispatchTable.CmdSetPrimitiveTopology(commandBuffer, primitiveTopology);
    recordVoidFunction(VK_FUNCTION_CMD_SET_PRIMITIVE_TOPOLOGY_MWN, commandBuffer, primitiveTopology);
}
void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports)
{
    g_dispatchTable.CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports);
    recordVoidFunction(VK_FUNCTION_CMD_SET_VIEWPORT_WITH_COUNT_MWN, commandBuffer, viewportCount, pViewports);
}
void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors)
{
    g_dispatchTable.CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors);
    recordVoidFunction(VK_FUNCTION_CMD_SET_SCISSOR_WITH_COUNT_MWN, commandBuffer, scissorCount, pScissors);
}
void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides)
{
    g_dispatchTable.CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
    recordVoidFunction(VK_FUNCTION_CMD_BIND_VERTEX_BUFFERS2_MWN, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
}
void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable)
{
    g_dispatchTable.CmdSetDepthTestEnable(commandBuffer, depthTestEnable);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_TEST_ENABLE_MWN, commandBuffer, depthTestEnable);
}
void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable)
{
    g_dispatchTable.CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_WRITE_ENABLE_MWN, commandBuffer, depthWriteEnable);
}
void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp)
{
    g_dispatchTable.CmdSetDepthCompareOp(commandBuffer, depthCompareOp);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_COMPARE_OP_MWN, commandBuffer, depthCompareOp);
}
void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable)
{
    g_dispatchTable.CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_BOUNDS_TEST_ENABLE_MWN, commandBuffer, depthBoundsTestEnable);
}
void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable)
{
    g_dispatchTable.CmdSetStencilTestEnable(commandBuffer, stencilTestEnable);
    recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_TEST_ENABLE_MWN, commandBuffer, stencilTestEnable);
}
void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp)
{
    g_dispatchTable.CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
    recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_OP_MWN, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp);
}
void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints)
{
    g_dispatchTable.CmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints);
    recordVoidFunction(VK_FUNCTION_CMD_SET_PATCH_CONTROL_POINTS_EXT_MWN, commandBuffer, patchControlPoints);
}
void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable)
{
    g_dispatchTable.CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable);
    recordVoidFunction(VK_FUNCTION_CMD_SET_RASTERIZER_DISCARD_ENABLE_MWN, commandBuffer, rasterizerDiscardEnable);
}
void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable)
{
    g_dispatchTable.CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable);
    recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_BIAS_ENABLE_MWN, commandBuffer, depthBiasEnable);
}
void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp)
{
    g_dispatchTable.CmdSetLogicOpEXT(commandBuffer, logicOp);
    recordVoidFunction(VK_FUNCTION_CMD_SET_LOGIC_OP_EXT_MWN, commandBuffer, logicOp);
}
void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable)
{
    g_dispatchTable.CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable);
    recordVoidFunction(VK_FUNCTION_CMD_SET_PRIMITIVE_RESTART_ENABLE_MWN, commandBuffer, primitiveRestartEnable);
}
VkResult vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot)
{
    auto result = g_dispatchTable.CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot);
    recordFunction(VK_FUNCTION_CREATE_PRIVATE_DATA_SLOT_MWN, result, device, pCreateInfo, pAllocator, pPrivateDataSlot);
    return result;
}
void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyPrivateDataSlot(device, privateDataSlot, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_PRIVATE_DATA_SLOT_MWN, device, privateDataSlot, pAllocator);
}
VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data)
{
    auto result = g_dispatchTable.SetPrivateData(device, objectType, objectHandle, privateDataSlot, data);
    recordFunction(VK_FUNCTION_SET_PRIVATE_DATA_MWN, result, device, objectType, objectHandle, privateDataSlot, data);
    return result;
}
void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData)
{
    g_dispatchTable.GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData);
    recordVoidFunction(VK_FUNCTION_GET_PRIVATE_DATA_MWN, device, objectType, objectHandle, privateDataSlot, pData);
}
void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo)
{
    g_dispatchTable.CmdCopyBuffer2(commandBuffer, pCopyBufferInfo);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_BUFFER2_MWN, commandBuffer, pCopyBufferInfo);
}
void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo)
{
    g_dispatchTable.CmdCopyImage2(commandBuffer, pCopyImageInfo);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_IMAGE2_MWN, commandBuffer, pCopyImageInfo);
}
void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo)
{
    g_dispatchTable.CmdBlitImage2(commandBuffer, pBlitImageInfo);
    recordVoidFunction(VK_FUNCTION_CMD_BLIT_IMAGE2_MWN, commandBuffer, pBlitImageInfo);
}
void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo)
{
    g_dispatchTable.CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_BUFFER_TO_IMAGE2_MWN, commandBuffer, pCopyBufferToImageInfo);
}
void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo)
{
    g_dispatchTable.CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo);
    recordVoidFunction(VK_FUNCTION_CMD_COPY_IMAGE_TO_BUFFER2_MWN, commandBuffer, pCopyImageToBufferInfo);
}
void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo)
{
    g_dispatchTable.CmdResolveImage2(commandBuffer, pResolveImageInfo);
    recordVoidFunction(VK_FUNCTION_CMD_RESOLVE_IMAGE2_MWN, commandBuffer, pResolveImageInfo);
}
void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
{
    g_dispatchTable.CmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps);
    recordVoidFunction(VK_FUNCTION_CMD_SET_FRAGMENT_SHADING_RATE_KHR_MWN, commandBuffer, pFragmentSize, combinerOps);
}
void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2])
{
    g_dispatchTable.CmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps);
    recordVoidFunction(VK_FUNCTION_CMD_SET_FRAGMENT_SHADING_RATE_ENUM_NV_MWN, commandBuffer, shadingRate, combinerOps);
}
void vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo)
{
    g_dispatchTable.GetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
    recordVoidFunction(VK_FUNCTION_GET_ACCELERATION_STRUCTURE_BUILD_SIZES_KHR_MWN, device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo);
}
void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions)
{
    g_dispatchTable.CmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
    recordVoidFunction(VK_FUNCTION_CMD_SET_VERTEX_INPUT_EXT_MWN, commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions);
}
void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables)
{
    g_dispatchTable.CmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables);
    recordVoidFunction(VK_FUNCTION_CMD_SET_COLOR_WRITE_ENABLE_EXT_MWN, commandBuffer, attachmentCount, pColorWriteEnables);
}
void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo)
{
    g_dispatchTable.CmdSetEvent2(commandBuffer, event, pDependencyInfo);
    recordVoidFunction(VK_FUNCTION_CMD_SET_EVENT2_MWN, commandBuffer, event, pDependencyInfo);
}
void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask)
{
    g_dispatchTable.CmdResetEvent2(commandBuffer, event, stageMask);
    recordVoidFunction(VK_FUNCTION_CMD_RESET_EVENT2_MWN, commandBuffer, event, stageMask);
}
void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos)
{
    g_dispatchTable.CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos);
    recordVoidFunction(VK_FUNCTION_CMD_WAIT_EVENTS2_MWN, commandBuffer, eventCount, pEvents, pDependencyInfos);
}
void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo)
{
    g_dispatchTable.CmdPipelineBarrier2(commandBuffer, pDependencyInfo);
    recordVoidFunction(VK_FUNCTION_CMD_PIPELINE_BARRIER2_MWN, commandBuffer, pDependencyInfo);
}
VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence)
{
    auto result = g_dispatchTable.QueueSubmit2(queue, submitCount, pSubmits, fence);
    recordFunction(VK_FUNCTION_QUEUE_SUBMIT2_MWN, result, queue, submitCount, pSubmits, fence);
    return result;
}
void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query)
{
    g_dispatchTable.CmdWriteTimestamp2(commandBuffer, stage, queryPool, query);
    recordVoidFunction(VK_FUNCTION_CMD_WRITE_TIMESTAMP2_MWN, commandBuffer, stage, queryPool, query);
}
void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker)
{
    g_dispatchTable.CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker);
    recordVoidFunction(VK_FUNCTION_CMD_WRITE_BUFFER_MARKER2_AMD_MWN, commandBuffer, stage, dstBuffer, dstOffset, marker);
}
void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData)
{
    g_dispatchTable.GetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData);
    recordVoidFunction(VK_FUNCTION_GET_QUEUE_CHECKPOINT_DATA2_NV_MWN, queue, pCheckpointDataCount, pCheckpointData);
}
VkResult vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule)
{
    auto result = g_dispatchTable.CreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule);
    recordFunction(VK_FUNCTION_CREATE_CU_MODULE_NVX_MWN, result, device, pCreateInfo, pAllocator, pModule);
    return result;
}
VkResult vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction)
{
    auto result = g_dispatchTable.CreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction);
    recordFunction(VK_FUNCTION_CREATE_CU_FUNCTION_NVX_MWN, result, device, pCreateInfo, pAllocator, pFunction);
    return result;
}
void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyCuModuleNVX(device, module, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_CU_MODULE_NVX_MWN, device, module, pAllocator);
}
void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyCuFunctionNVX(device, function, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_CU_FUNCTION_NVX_MWN, device, function, pAllocator);
}
void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo)
{
    g_dispatchTable.CmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo);
    recordVoidFunction(VK_FUNCTION_CMD_CU_LAUNCH_KERNEL_NVX_MWN, commandBuffer, pLaunchInfo);
}
void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority)
{
    g_dispatchTable.SetDeviceMemoryPriorityEXT(device, memory, priority);
    recordVoidFunction(VK_FUNCTION_SET_DEVICE_MEMORY_PRIORITY_EXT_MWN, device, memory, priority);
}
VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout)
{
    auto result = g_dispatchTable.WaitForPresentKHR(device, swapchain, presentId, timeout);
    recordFunction(VK_FUNCTION_WAIT_FOR_PRESENT_KHR_MWN, result, device, swapchain, presentId, timeout);
    return result;
}
void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo)
{
    g_dispatchTable.CmdBeginRendering(commandBuffer, pRenderingInfo);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_RENDERING_MWN, commandBuffer, pRenderingInfo);
}
void vkCmdEndRendering(VkCommandBuffer commandBuffer)
{
    g_dispatchTable.CmdEndRendering(commandBuffer);
    recordVoidFunction(VK_FUNCTION_CMD_END_RENDERING_MWN, commandBuffer);
}
void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping)
{
    g_dispatchTable.GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping);
    recordVoidFunction(VK_FUNCTION_GET_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE_MWN, device, pBindingReference, pHostMapping);
}
void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData)
{
    g_dispatchTable.GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData);
    recordVoidFunction(VK_FUNCTION_GET_DESCRIPTOR_SET_HOST_MAPPING_VALVE_MWN, device, descriptorSet, ppData);
}
void vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout)
{
    g_dispatchTable.GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout);
    recordVoidFunction(VK_FUNCTION_GET_IMAGE_SUBRESOURCE_LAYOUT2_EXT_MWN, device, image, pSubresource, pLayout);
}
VkResult vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties)
{
    auto result = g_dispatchTable.GetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties);
    recordFunction(VK_FUNCTION_GET_PIPELINE_PROPERTIES_EXT_MWN, result, device, pPipelineInfo, pPipelineProperties);
    return result;
}

#if defined(VK_USE_PLATFORM_ANDROID_KHR)
VkResult vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage)
{
    auto result = g_dispatchTable.GetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage);
    recordFunction(VK_FUNCTION_GET_SWAPCHAIN_GRALLOC_USAGE_ANDROID_MWN, result, device, format, imageUsage, grallocUsage);
    return result;
}
VkResult vkGetSwapchainGrallocUsage2ANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage)
{
    auto result = g_dispatchTable.GetSwapchainGrallocUsage2ANDROID(device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage);
    recordFunction(VK_FUNCTION_GET_SWAPCHAIN_GRALLOC_USAGE2_ANDROID_MWN, result, device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage);
    return result;
}
VkResult vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence)
{
    auto result = g_dispatchTable.AcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence);
    recordFunction(VK_FUNCTION_ACQUIRE_IMAGE_ANDROID_MWN, result, device, image, nativeFenceFd, semaphore, fence);
    return result;
}
VkResult vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd)
{
    auto result = g_dispatchTable.QueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
    recordFunction(VK_FUNCTION_QUEUE_SIGNAL_RELEASE_IMAGE_ANDROID_MWN, result, queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
    return result;
}
VkResult vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties)
{
    auto result = g_dispatchTable.GetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties);
    recordFunction(VK_FUNCTION_GET_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID_MWN, result, device, buffer, pProperties);
    return result;
}
VkResult vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer)
{
    auto result = g_dispatchTable.GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
    recordFunction(VK_FUNCTION_GET_MEMORY_ANDROID_HARDWARE_BUFFER_ANDROID_MWN, result, device, pInfo, pBuffer);
    return result;
}

#endif // defined(VK_USE_PLATFORM_ANDROID_KHR)

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT)

#if defined(VK_USE_PLATFORM_FUCHSIA)
VkResult vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle)
{
    auto result = g_dispatchTable.GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
    recordFunction(VK_FUNCTION_GET_MEMORY_ZIRCON_HANDLE_FUCHSIA_MWN, result, device, pGetZirconHandleInfo, pZirconHandle);
    return result;
}
VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties)
{
    auto result = g_dispatchTable.GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties);
    recordFunction(VK_FUNCTION_GET_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA_MWN, result, device, handleType, zirconHandle, pMemoryZirconHandleProperties);
    return result;
}
VkResult vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle)
{
    auto result = g_dispatchTable.GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle);
    recordFunction(VK_FUNCTION_GET_SEMAPHORE_ZIRCON_HANDLE_FUCHSIA_MWN, result, device, pGetZirconHandleInfo, pZirconHandle);
    return result;
}
VkResult vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo)
{
    auto result = g_dispatchTable.ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo);
    recordFunction(VK_FUNCTION_IMPORT_SEMAPHORE_ZIRCON_HANDLE_FUCHSIA_MWN, result, device, pImportSemaphoreZirconHandleInfo);
    return result;
}
VkResult vkCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection)
{
    auto result = g_dispatchTable.CreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection);
    recordFunction(VK_FUNCTION_CREATE_BUFFER_COLLECTION_FUCHSIA_MWN, result, device, pCreateInfo, pAllocator, pCollection);
    return result;
}
VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo)
{
    auto result = g_dispatchTable.SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo);
    recordFunction(VK_FUNCTION_SET_BUFFER_COLLECTION_BUFFER_CONSTRAINTS_FUCHSIA_MWN, result, device, collection, pBufferConstraintsInfo);
    return result;
}
VkResult vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo)
{
    auto result = g_dispatchTable.SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo);
    recordFunction(VK_FUNCTION_SET_BUFFER_COLLECTION_IMAGE_CONSTRAINTS_FUCHSIA_MWN, result, device, collection, pImageConstraintsInfo);
    return result;
}
void vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyBufferCollectionFUCHSIA(device, collection, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_BUFFER_COLLECTION_FUCHSIA_MWN, device, collection, pAllocator);
}
VkResult vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties)
{
    auto result = g_dispatchTable.GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties);
    recordFunction(VK_FUNCTION_GET_BUFFER_COLLECTION_PROPERTIES_FUCHSIA_MWN, result, device, collection, pProperties);
    return result;
}

#endif // defined(VK_USE_PLATFORM_FUCHSIA)

#if defined(VK_USE_PLATFORM_GGP)

#endif // defined(VK_USE_PLATFORM_GGP)

#if defined(VK_USE_PLATFORM_IOS_MVK)

#endif // defined(VK_USE_PLATFORM_IOS_MVK)

#if defined(VK_USE_PLATFORM_MACOS_MVK)

#endif // defined(VK_USE_PLATFORM_MACOS_MVK)

#if defined(VK_USE_PLATFORM_METAL_EXT)
void vkExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo)
{
    g_dispatchTable.ExportMetalObjectsEXT(device, pMetalObjectsInfo);
    recordVoidFunction(VK_FUNCTION_EXPORT_METAL_OBJECTS_EXT_MWN, device, pMetalObjectsInfo);
}

#endif // defined(VK_USE_PLATFORM_METAL_EXT)

#if defined(VK_ENABLE_BETA_EXTENSIONS)
VkResult vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession)
{
    auto result = g_dispatchTable.CreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession);
    recordFunction(VK_FUNCTION_CREATE_VIDEO_SESSION_KHR_MWN, result, device, pCreateInfo, pAllocator, pVideoSession);
    return result;
}
void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyVideoSessionKHR(device, videoSession, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_VIDEO_SESSION_KHR_MWN, device, videoSession, pAllocator);
}
VkResult vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters)
{
    auto result = g_dispatchTable.CreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters);
    recordFunction(VK_FUNCTION_CREATE_VIDEO_SESSION_PARAMETERS_KHR_MWN, result, device, pCreateInfo, pAllocator, pVideoSessionParameters);
    return result;
}
VkResult vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo)
{
    auto result = g_dispatchTable.UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo);
    recordFunction(VK_FUNCTION_UPDATE_VIDEO_SESSION_PARAMETERS_KHR_MWN, result, device, videoSessionParameters, pUpdateInfo);
    return result;
}
void vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator)
{
    g_dispatchTable.DestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator);
    recordVoidFunction(VK_FUNCTION_DESTROY_VIDEO_SESSION_PARAMETERS_KHR_MWN, device, videoSessionParameters, pAllocator);
}
VkResult vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements)
{
    auto result = g_dispatchTable.GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements);
    recordFunction(VK_FUNCTION_GET_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR_MWN, result, device, videoSession, pMemoryRequirementsCount, pMemoryRequirements);
    return result;
}
VkResult vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos)
{
    auto result = g_dispatchTable.BindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos);
    recordFunction(VK_FUNCTION_BIND_VIDEO_SESSION_MEMORY_KHR_MWN, result, device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos);
    return result;
}
void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo)
{
    g_dispatchTable.CmdDecodeVideoKHR(commandBuffer, pFrameInfo);
    recordVoidFunction(VK_FUNCTION_CMD_DECODE_VIDEO_KHR_MWN, commandBuffer, pFrameInfo);
}
void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo)
{
    g_dispatchTable.CmdBeginVideoCodingKHR(commandBuffer, pBeginInfo);
    recordVoidFunction(VK_FUNCTION_CMD_BEGIN_VIDEO_CODING_KHR_MWN, commandBuffer, pBeginInfo);
}
void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo)
{
    g_dispatchTable.CmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo);
    recordVoidFunction(VK_FUNCTION_CMD_CONTROL_VIDEO_CODING_KHR_MWN, commandBuffer, pCodingControlInfo);
}
void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo)
{
    g_dispatchTable.CmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo);
    recordVoidFunction(VK_FUNCTION_CMD_END_VIDEO_CODING_KHR_MWN, commandBuffer, pEndCodingInfo);
}
void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo)
{
    g_dispatchTable.CmdEncodeVideoKHR(commandBuffer, pEncodeInfo);
    recordVoidFunction(VK_FUNCTION_CMD_ENCODE_VIDEO_KHR_MWN, commandBuffer, pEncodeInfo);
}

#endif // defined(VK_ENABLE_BETA_EXTENSIONS)

#if defined(VK_USE_PLATFORM_SCREEN_QNX)

#endif // defined(VK_USE_PLATFORM_SCREEN_QNX)

#if defined(VK_USE_PLATFORM_VI_NN)

#endif // defined(VK_USE_PLATFORM_VI_NN)

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR)

#if defined(VK_USE_PLATFORM_WIN32_KHR)
VkResult vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle)
{
    auto result = g_dispatchTable.GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
    recordFunction(VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_NV_MWN, result, device, memory, handleType, pHandle);
    return result;
}
VkResult vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle)
{
    auto result = g_dispatchTable.GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
    recordFunction(VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_KHR_MWN, result, device, pGetWin32HandleInfo, pHandle);
    return result;
}
VkResult vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
{
    auto result = g_dispatchTable.GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
    recordFunction(VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_PROPERTIES_KHR_MWN, result, device, handleType, handle, pMemoryWin32HandleProperties);
    return result;
}
VkResult vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle)
{
    auto result = g_dispatchTable.GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
    recordFunction(VK_FUNCTION_GET_SEMAPHORE_WIN32_HANDLE_KHR_MWN, result, device, pGetWin32HandleInfo, pHandle);
    return result;
}
VkResult vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
{
    auto result = g_dispatchTable.ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
    recordFunction(VK_FUNCTION_IMPORT_SEMAPHORE_WIN32_HANDLE_KHR_MWN, result, device, pImportSemaphoreWin32HandleInfo);
    return result;
}
VkResult vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle)
{
    auto result = g_dispatchTable.GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
    recordFunction(VK_FUNCTION_GET_FENCE_WIN32_HANDLE_KHR_MWN, result, device, pGetWin32HandleInfo, pHandle);
    return result;
}
VkResult vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
{
    auto result = g_dispatchTable.ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
    recordFunction(VK_FUNCTION_IMPORT_FENCE_WIN32_HANDLE_KHR_MWN, result, device, pImportFenceWin32HandleInfo);
    return result;
}
VkResult vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain)
{
    auto result = g_dispatchTable.AcquireFullScreenExclusiveModeEXT(device, swapchain);
    recordFunction(VK_FUNCTION_ACQUIRE_FULL_SCREEN_EXCLUSIVE_MODE_EXT_MWN, result, device, swapchain);
    return result;
}
VkResult vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain)
{
    auto result = g_dispatchTable.ReleaseFullScreenExclusiveModeEXT(device, swapchain);
    recordFunction(VK_FUNCTION_RELEASE_FULL_SCREEN_EXCLUSIVE_MODE_EXT_MWN, result, device, swapchain);
    return result;
}

#endif // defined(VK_USE_PLATFORM_WIN32_KHR)

#if defined(VK_USE_PLATFORM_XCB_KHR)

#endif // defined(VK_USE_PLATFORM_XCB_KHR)

#if defined(VK_USE_PLATFORM_XLIB_KHR)

#endif // defined(VK_USE_PLATFORM_XLIB_KHR)

#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
#endif // defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)
PFN_vkVoidFunction getWrappedFunctionPtr(const char* pName)
{
        
    if (std::strcmp(pName, "vkGetDeviceQueue") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceQueue);
    } else
    if (std::strcmp(pName, "vkQueueSubmit") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueSubmit);
    } else
    if (std::strcmp(pName, "vkQueueWaitIdle") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueWaitIdle);
    } else
    if (std::strcmp(pName, "vkDeviceWaitIdle") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDeviceWaitIdle);
    } else
    if (std::strcmp(pName, "vkAllocateMemory") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAllocateMemory);
    } else
    if (std::strcmp(pName, "vkFreeMemory") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkFreeMemory);
    } else
    if (std::strcmp(pName, "vkMapMemory") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkMapMemory);
    } else
    if (std::strcmp(pName, "vkUnmapMemory") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkUnmapMemory);
    } else
    if (std::strcmp(pName, "vkFlushMappedMemoryRanges") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkFlushMappedMemoryRanges);
    } else
    if (std::strcmp(pName, "vkInvalidateMappedMemoryRanges") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkInvalidateMappedMemoryRanges);
    } else
    if (std::strcmp(pName, "vkGetDeviceMemoryCommitment") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceMemoryCommitment);
    } else
    if (std::strcmp(pName, "vkGetBufferMemoryRequirements") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkBindBufferMemory") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBindBufferMemory);
    } else
    if (std::strcmp(pName, "vkGetImageMemoryRequirements") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkBindImageMemory") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBindImageMemory);
    } else
    if (std::strcmp(pName, "vkGetImageSparseMemoryRequirements") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageSparseMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkQueueBindSparse") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueBindSparse);
    } else
    if (std::strcmp(pName, "vkCreateFence") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateFence);
    } else
    if (std::strcmp(pName, "vkDestroyFence") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyFence);
    } else
    if (std::strcmp(pName, "vkResetFences") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkResetFences);
    } else
    if (std::strcmp(pName, "vkGetFenceStatus") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetFenceStatus);
    } else
    if (std::strcmp(pName, "vkWaitForFences") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkWaitForFences);
    } else
    if (std::strcmp(pName, "vkCreateSemaphore") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateSemaphore);
    } else
    if (std::strcmp(pName, "vkDestroySemaphore") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroySemaphore);
    } else
    if (std::strcmp(pName, "vkCreateEvent") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateEvent);
    } else
    if (std::strcmp(pName, "vkDestroyEvent") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyEvent);
    } else
    if (std::strcmp(pName, "vkGetEventStatus") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetEventStatus);
    } else
    if (std::strcmp(pName, "vkSetEvent") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetEvent);
    } else
    if (std::strcmp(pName, "vkResetEvent") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkResetEvent);
    } else
    if (std::strcmp(pName, "vkCreateQueryPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateQueryPool);
    } else
    if (std::strcmp(pName, "vkDestroyQueryPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyQueryPool);
    } else
    if (std::strcmp(pName, "vkGetQueryPoolResults") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetQueryPoolResults);
    } else
    if (std::strcmp(pName, "vkResetQueryPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkResetQueryPool);
    } else
    if (std::strcmp(pName, "vkResetQueryPoolEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkResetQueryPool);
    } else
    if (std::strcmp(pName, "vkCreateBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateBuffer);
    } else
    if (std::strcmp(pName, "vkDestroyBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyBuffer);
    } else
    if (std::strcmp(pName, "vkCreateBufferView") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateBufferView);
    } else
    if (std::strcmp(pName, "vkDestroyBufferView") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyBufferView);
    } else
    if (std::strcmp(pName, "vkCreateImage") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateImage);
    } else
    if (std::strcmp(pName, "vkDestroyImage") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyImage);
    } else
    if (std::strcmp(pName, "vkGetImageSubresourceLayout") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageSubresourceLayout);
    } else
    if (std::strcmp(pName, "vkCreateImageView") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateImageView);
    } else
    if (std::strcmp(pName, "vkDestroyImageView") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyImageView);
    } else
    if (std::strcmp(pName, "vkCreateShaderModule") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateShaderModule);
    } else
    if (std::strcmp(pName, "vkDestroyShaderModule") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyShaderModule);
    } else
    if (std::strcmp(pName, "vkCreatePipelineCache") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreatePipelineCache);
    } else
    if (std::strcmp(pName, "vkDestroyPipelineCache") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyPipelineCache);
    } else
    if (std::strcmp(pName, "vkGetPipelineCacheData") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPipelineCacheData);
    } else
    if (std::strcmp(pName, "vkMergePipelineCaches") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkMergePipelineCaches);
    } else
    if (std::strcmp(pName, "vkCreateGraphicsPipelines") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateGraphicsPipelines);
    } else
    if (std::strcmp(pName, "vkCreateComputePipelines") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateComputePipelines);
    } else
    if (std::strcmp(pName, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI);
    } else
    if (std::strcmp(pName, "vkDestroyPipeline") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyPipeline);
    } else
    if (std::strcmp(pName, "vkCreatePipelineLayout") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreatePipelineLayout);
    } else
    if (std::strcmp(pName, "vkDestroyPipelineLayout") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyPipelineLayout);
    } else
    if (std::strcmp(pName, "vkCreateSampler") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateSampler);
    } else
    if (std::strcmp(pName, "vkDestroySampler") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroySampler);
    } else
    if (std::strcmp(pName, "vkCreateDescriptorSetLayout") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateDescriptorSetLayout);
    } else
    if (std::strcmp(pName, "vkDestroyDescriptorSetLayout") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyDescriptorSetLayout);
    } else
    if (std::strcmp(pName, "vkCreateDescriptorPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateDescriptorPool);
    } else
    if (std::strcmp(pName, "vkDestroyDescriptorPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyDescriptorPool);
    } else
    if (std::strcmp(pName, "vkResetDescriptorPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkResetDescriptorPool);
    } else
    if (std::strcmp(pName, "vkAllocateDescriptorSets") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAllocateDescriptorSets);
    } else
    if (std::strcmp(pName, "vkFreeDescriptorSets") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkFreeDescriptorSets);
    } else
    if (std::strcmp(pName, "vkUpdateDescriptorSets") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkUpdateDescriptorSets);
    } else
    if (std::strcmp(pName, "vkCreateFramebuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateFramebuffer);
    } else
    if (std::strcmp(pName, "vkDestroyFramebuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyFramebuffer);
    } else
    if (std::strcmp(pName, "vkCreateRenderPass") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateRenderPass);
    } else
    if (std::strcmp(pName, "vkDestroyRenderPass") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyRenderPass);
    } else
    if (std::strcmp(pName, "vkGetRenderAreaGranularity") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetRenderAreaGranularity);
    } else
    if (std::strcmp(pName, "vkCreateCommandPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateCommandPool);
    } else
    if (std::strcmp(pName, "vkDestroyCommandPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyCommandPool);
    } else
    if (std::strcmp(pName, "vkResetCommandPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkResetCommandPool);
    } else
    if (std::strcmp(pName, "vkAllocateCommandBuffers") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAllocateCommandBuffers);
    } else
    if (std::strcmp(pName, "vkFreeCommandBuffers") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkFreeCommandBuffers);
    } else
    if (std::strcmp(pName, "vkBeginCommandBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBeginCommandBuffer);
    } else
    if (std::strcmp(pName, "vkEndCommandBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkEndCommandBuffer);
    } else
    if (std::strcmp(pName, "vkResetCommandBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkResetCommandBuffer);
    } else
    if (std::strcmp(pName, "vkCmdBindPipeline") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindPipeline);
    } else
    if (std::strcmp(pName, "vkCmdSetViewport") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetViewport);
    } else
    if (std::strcmp(pName, "vkCmdSetScissor") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetScissor);
    } else
    if (std::strcmp(pName, "vkCmdSetLineWidth") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetLineWidth);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthBias") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthBias);
    } else
    if (std::strcmp(pName, "vkCmdSetBlendConstants") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetBlendConstants);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthBounds") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthBounds);
    } else
    if (std::strcmp(pName, "vkCmdSetStencilCompareMask") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetStencilCompareMask);
    } else
    if (std::strcmp(pName, "vkCmdSetStencilWriteMask") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetStencilWriteMask);
    } else
    if (std::strcmp(pName, "vkCmdSetStencilReference") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetStencilReference);
    } else
    if (std::strcmp(pName, "vkCmdBindDescriptorSets") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindDescriptorSets);
    } else
    if (std::strcmp(pName, "vkCmdBindIndexBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindIndexBuffer);
    } else
    if (std::strcmp(pName, "vkCmdBindVertexBuffers") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindVertexBuffers);
    } else
    if (std::strcmp(pName, "vkCmdDraw") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDraw);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndexed") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndexed);
    } else
    if (std::strcmp(pName, "vkCmdDrawMultiEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawMultiEXT);
    } else
    if (std::strcmp(pName, "vkCmdDrawMultiIndexedEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawMultiIndexedEXT);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndirect") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndirect);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndexedIndirect") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndexedIndirect);
    } else
    if (std::strcmp(pName, "vkCmdDispatch") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDispatch);
    } else
    if (std::strcmp(pName, "vkCmdDispatchIndirect") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDispatchIndirect);
    } else
    if (std::strcmp(pName, "vkCmdSubpassShadingHUAWEI") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSubpassShadingHUAWEI);
    } else
    if (std::strcmp(pName, "vkCmdCopyBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyBuffer);
    } else
    if (std::strcmp(pName, "vkCmdCopyImage") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyImage);
    } else
    if (std::strcmp(pName, "vkCmdBlitImage") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBlitImage);
    } else
    if (std::strcmp(pName, "vkCmdCopyBufferToImage") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyBufferToImage);
    } else
    if (std::strcmp(pName, "vkCmdCopyImageToBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyImageToBuffer);
    } else
    if (std::strcmp(pName, "vkCmdUpdateBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdUpdateBuffer);
    } else
    if (std::strcmp(pName, "vkCmdFillBuffer") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdFillBuffer);
    } else
    if (std::strcmp(pName, "vkCmdClearColorImage") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdClearColorImage);
    } else
    if (std::strcmp(pName, "vkCmdClearDepthStencilImage") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdClearDepthStencilImage);
    } else
    if (std::strcmp(pName, "vkCmdClearAttachments") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdClearAttachments);
    } else
    if (std::strcmp(pName, "vkCmdResolveImage") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdResolveImage);
    } else
    if (std::strcmp(pName, "vkCmdSetEvent") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetEvent);
    } else
    if (std::strcmp(pName, "vkCmdResetEvent") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdResetEvent);
    } else
    if (std::strcmp(pName, "vkCmdWaitEvents") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWaitEvents);
    } else
    if (std::strcmp(pName, "vkCmdPipelineBarrier") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdPipelineBarrier);
    } else
    if (std::strcmp(pName, "vkCmdBeginQuery") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginQuery);
    } else
    if (std::strcmp(pName, "vkCmdEndQuery") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndQuery);
    } else
    if (std::strcmp(pName, "vkCmdBeginConditionalRenderingEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginConditionalRenderingEXT);
    } else
    if (std::strcmp(pName, "vkCmdEndConditionalRenderingEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndConditionalRenderingEXT);
    } else
    if (std::strcmp(pName, "vkCmdResetQueryPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdResetQueryPool);
    } else
    if (std::strcmp(pName, "vkCmdWriteTimestamp") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWriteTimestamp);
    } else
    if (std::strcmp(pName, "vkCmdCopyQueryPoolResults") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyQueryPoolResults);
    } else
    if (std::strcmp(pName, "vkCmdPushConstants") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdPushConstants);
    } else
    if (std::strcmp(pName, "vkCmdBeginRenderPass") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginRenderPass);
    } else
    if (std::strcmp(pName, "vkCmdNextSubpass") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdNextSubpass);
    } else
    if (std::strcmp(pName, "vkCmdEndRenderPass") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndRenderPass);
    } else
    if (std::strcmp(pName, "vkCmdExecuteCommands") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdExecuteCommands);
    } else
    if (std::strcmp(pName, "vkCreateSharedSwapchainsKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateSharedSwapchainsKHR);
    } else
    if (std::strcmp(pName, "vkCreateSwapchainKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateSwapchainKHR);
    } else
    if (std::strcmp(pName, "vkDestroySwapchainKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroySwapchainKHR);
    } else
    if (std::strcmp(pName, "vkGetSwapchainImagesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSwapchainImagesKHR);
    } else
    if (std::strcmp(pName, "vkAcquireNextImageKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAcquireNextImageKHR);
    } else
    if (std::strcmp(pName, "vkQueuePresentKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueuePresentKHR);
    } else
    if (std::strcmp(pName, "vkDebugMarkerSetObjectNameEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDebugMarkerSetObjectNameEXT);
    } else
    if (std::strcmp(pName, "vkDebugMarkerSetObjectTagEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDebugMarkerSetObjectTagEXT);
    } else
    if (std::strcmp(pName, "vkCmdDebugMarkerBeginEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDebugMarkerBeginEXT);
    } else
    if (std::strcmp(pName, "vkCmdDebugMarkerEndEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDebugMarkerEndEXT);
    } else
    if (std::strcmp(pName, "vkCmdDebugMarkerInsertEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDebugMarkerInsertEXT);
    } else
    if (std::strcmp(pName, "vkCmdExecuteGeneratedCommandsNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdExecuteGeneratedCommandsNV);
    } else
    if (std::strcmp(pName, "vkCmdPreprocessGeneratedCommandsNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdPreprocessGeneratedCommandsNV);
    } else
    if (std::strcmp(pName, "vkCmdBindPipelineShaderGroupNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindPipelineShaderGroupNV);
    } else
    if (std::strcmp(pName, "vkGetGeneratedCommandsMemoryRequirementsNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetGeneratedCommandsMemoryRequirementsNV);
    } else
    if (std::strcmp(pName, "vkCreateIndirectCommandsLayoutNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateIndirectCommandsLayoutNV);
    } else
    if (std::strcmp(pName, "vkDestroyIndirectCommandsLayoutNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyIndirectCommandsLayoutNV);
    } else
    if (std::strcmp(pName, "vkCmdPushDescriptorSetKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdPushDescriptorSetKHR);
    } else
    if (std::strcmp(pName, "vkTrimCommandPool") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkTrimCommandPool);
    } else
    if (std::strcmp(pName, "vkTrimCommandPoolKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkTrimCommandPool);
    } else
    if (std::strcmp(pName, "vkGetMemoryFdKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryFdKHR);
    } else
    if (std::strcmp(pName, "vkGetMemoryFdPropertiesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryFdPropertiesKHR);
    } else
    if (std::strcmp(pName, "vkGetMemoryRemoteAddressNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryRemoteAddressNV);
    } else
    if (std::strcmp(pName, "vkGetSemaphoreFdKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSemaphoreFdKHR);
    } else
    if (std::strcmp(pName, "vkImportSemaphoreFdKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkImportSemaphoreFdKHR);
    } else
    if (std::strcmp(pName, "vkGetFenceFdKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetFenceFdKHR);
    } else
    if (std::strcmp(pName, "vkImportFenceFdKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkImportFenceFdKHR);
    } else
    if (std::strcmp(pName, "vkDisplayPowerControlEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDisplayPowerControlEXT);
    } else
    if (std::strcmp(pName, "vkRegisterDeviceEventEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkRegisterDeviceEventEXT);
    } else
    if (std::strcmp(pName, "vkRegisterDisplayEventEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkRegisterDisplayEventEXT);
    } else
    if (std::strcmp(pName, "vkGetSwapchainCounterEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSwapchainCounterEXT);
    } else
    if (std::strcmp(pName, "vkGetDeviceGroupPeerMemoryFeatures") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceGroupPeerMemoryFeatures);
    } else
    if (std::strcmp(pName, "vkGetDeviceGroupPeerMemoryFeaturesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceGroupPeerMemoryFeatures);
    } else
    if (std::strcmp(pName, "vkBindBufferMemory2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBindBufferMemory2);
    } else
    if (std::strcmp(pName, "vkBindBufferMemory2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBindBufferMemory2);
    } else
    if (std::strcmp(pName, "vkBindImageMemory2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBindImageMemory2);
    } else
    if (std::strcmp(pName, "vkBindImageMemory2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBindImageMemory2);
    } else
    if (std::strcmp(pName, "vkCmdSetDeviceMask") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDeviceMask);
    } else
    if (std::strcmp(pName, "vkCmdSetDeviceMaskKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDeviceMask);
    } else
    if (std::strcmp(pName, "vkGetDeviceGroupPresentCapabilitiesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceGroupPresentCapabilitiesKHR);
    } else
    if (std::strcmp(pName, "vkGetDeviceGroupSurfacePresentModesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceGroupSurfacePresentModesKHR);
    } else
    if (std::strcmp(pName, "vkAcquireNextImage2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAcquireNextImage2KHR);
    } else
    if (std::strcmp(pName, "vkCmdDispatchBase") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDispatchBase);
    } else
    if (std::strcmp(pName, "vkCmdDispatchBaseKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDispatchBase);
    } else
    if (std::strcmp(pName, "vkCreateDescriptorUpdateTemplate") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateDescriptorUpdateTemplate);
    } else
    if (std::strcmp(pName, "vkCreateDescriptorUpdateTemplateKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateDescriptorUpdateTemplate);
    } else
    if (std::strcmp(pName, "vkDestroyDescriptorUpdateTemplate") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyDescriptorUpdateTemplate);
    } else
    if (std::strcmp(pName, "vkDestroyDescriptorUpdateTemplateKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyDescriptorUpdateTemplate);
    } else
    if (std::strcmp(pName, "vkUpdateDescriptorSetWithTemplate") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkUpdateDescriptorSetWithTemplate);
    } else
    if (std::strcmp(pName, "vkUpdateDescriptorSetWithTemplateKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkUpdateDescriptorSetWithTemplate);
    } else
    if (std::strcmp(pName, "vkCmdPushDescriptorSetWithTemplateKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdPushDescriptorSetWithTemplateKHR);
    } else
    if (std::strcmp(pName, "vkSetHdrMetadataEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetHdrMetadataEXT);
    } else
    if (std::strcmp(pName, "vkGetSwapchainStatusKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSwapchainStatusKHR);
    } else
    if (std::strcmp(pName, "vkGetRefreshCycleDurationGOOGLE") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetRefreshCycleDurationGOOGLE);
    } else
    if (std::strcmp(pName, "vkGetPastPresentationTimingGOOGLE") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPastPresentationTimingGOOGLE);
    } else
    if (std::strcmp(pName, "vkCmdSetViewportWScalingNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetViewportWScalingNV);
    } else
    if (std::strcmp(pName, "vkCmdSetDiscardRectangleEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDiscardRectangleEXT);
    } else
    if (std::strcmp(pName, "vkCmdSetSampleLocationsEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetSampleLocationsEXT);
    } else
    if (std::strcmp(pName, "vkGetBufferMemoryRequirements2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferMemoryRequirements2);
    } else
    if (std::strcmp(pName, "vkGetBufferMemoryRequirements2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferMemoryRequirements2);
    } else
    if (std::strcmp(pName, "vkGetImageMemoryRequirements2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageMemoryRequirements2);
    } else
    if (std::strcmp(pName, "vkGetImageMemoryRequirements2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageMemoryRequirements2);
    } else
    if (std::strcmp(pName, "vkGetImageSparseMemoryRequirements2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageSparseMemoryRequirements2);
    } else
    if (std::strcmp(pName, "vkGetImageSparseMemoryRequirements2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageSparseMemoryRequirements2);
    } else
    if (std::strcmp(pName, "vkGetDeviceBufferMemoryRequirements") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceBufferMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkGetDeviceBufferMemoryRequirementsKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceBufferMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkGetDeviceImageMemoryRequirements") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceImageMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkGetDeviceImageMemoryRequirementsKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceImageMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkGetDeviceImageSparseMemoryRequirements") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceImageSparseMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkGetDeviceImageSparseMemoryRequirementsKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceImageSparseMemoryRequirements);
    } else
    if (std::strcmp(pName, "vkCreateSamplerYcbcrConversion") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateSamplerYcbcrConversion);
    } else
    if (std::strcmp(pName, "vkCreateSamplerYcbcrConversionKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateSamplerYcbcrConversion);
    } else
    if (std::strcmp(pName, "vkDestroySamplerYcbcrConversion") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroySamplerYcbcrConversion);
    } else
    if (std::strcmp(pName, "vkDestroySamplerYcbcrConversionKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroySamplerYcbcrConversion);
    } else
    if (std::strcmp(pName, "vkGetDeviceQueue2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceQueue2);
    } else
    if (std::strcmp(pName, "vkCreateValidationCacheEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateValidationCacheEXT);
    } else
    if (std::strcmp(pName, "vkDestroyValidationCacheEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyValidationCacheEXT);
    } else
    if (std::strcmp(pName, "vkGetValidationCacheDataEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetValidationCacheDataEXT);
    } else
    if (std::strcmp(pName, "vkMergeValidationCachesEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkMergeValidationCachesEXT);
    } else
    if (std::strcmp(pName, "vkGetDescriptorSetLayoutSupport") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDescriptorSetLayoutSupport);
    } else
    if (std::strcmp(pName, "vkGetDescriptorSetLayoutSupportKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDescriptorSetLayoutSupport);
    } else
    if (std::strcmp(pName, "vkGetShaderInfoAMD") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetShaderInfoAMD);
    } else
    if (std::strcmp(pName, "vkSetLocalDimmingAMD") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetLocalDimmingAMD);
    } else
    if (std::strcmp(pName, "vkGetCalibratedTimestampsEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetCalibratedTimestampsEXT);
    } else
    if (std::strcmp(pName, "vkSetDebugUtilsObjectNameEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetDebugUtilsObjectNameEXT);
    } else
    if (std::strcmp(pName, "vkSetDebugUtilsObjectTagEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetDebugUtilsObjectTagEXT);
    } else
    if (std::strcmp(pName, "vkQueueBeginDebugUtilsLabelEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueBeginDebugUtilsLabelEXT);
    } else
    if (std::strcmp(pName, "vkQueueEndDebugUtilsLabelEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueEndDebugUtilsLabelEXT);
    } else
    if (std::strcmp(pName, "vkQueueInsertDebugUtilsLabelEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueInsertDebugUtilsLabelEXT);
    } else
    if (std::strcmp(pName, "vkCmdBeginDebugUtilsLabelEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginDebugUtilsLabelEXT);
    } else
    if (std::strcmp(pName, "vkCmdEndDebugUtilsLabelEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndDebugUtilsLabelEXT);
    } else
    if (std::strcmp(pName, "vkCmdInsertDebugUtilsLabelEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdInsertDebugUtilsLabelEXT);
    } else
    if (std::strcmp(pName, "vkGetMemoryHostPointerPropertiesEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryHostPointerPropertiesEXT);
    } else
    if (std::strcmp(pName, "vkCmdWriteBufferMarkerAMD") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWriteBufferMarkerAMD);
    } else
    if (std::strcmp(pName, "vkCreateRenderPass2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateRenderPass2);
    } else
    if (std::strcmp(pName, "vkCreateRenderPass2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateRenderPass2);
    } else
    if (std::strcmp(pName, "vkCmdBeginRenderPass2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginRenderPass2);
    } else
    if (std::strcmp(pName, "vkCmdBeginRenderPass2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginRenderPass2);
    } else
    if (std::strcmp(pName, "vkCmdNextSubpass2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdNextSubpass2);
    } else
    if (std::strcmp(pName, "vkCmdNextSubpass2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdNextSubpass2);
    } else
    if (std::strcmp(pName, "vkCmdEndRenderPass2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndRenderPass2);
    } else
    if (std::strcmp(pName, "vkCmdEndRenderPass2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndRenderPass2);
    } else
    if (std::strcmp(pName, "vkGetSemaphoreCounterValue") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSemaphoreCounterValue);
    } else
    if (std::strcmp(pName, "vkGetSemaphoreCounterValueKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSemaphoreCounterValue);
    } else
    if (std::strcmp(pName, "vkWaitSemaphores") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkWaitSemaphores);
    } else
    if (std::strcmp(pName, "vkWaitSemaphoresKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkWaitSemaphores);
    } else
    if (std::strcmp(pName, "vkSignalSemaphore") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSignalSemaphore);
    } else
    if (std::strcmp(pName, "vkSignalSemaphoreKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSignalSemaphore);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndirectCount") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndirectCount);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndirectCountKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndirectCount);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndirectCountAMD") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndirectCount);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndexedIndirectCount") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndexedIndirectCount);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndexedIndirectCountKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndexedIndirectCount);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndexedIndirectCountAMD") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndexedIndirectCount);
    } else
    if (std::strcmp(pName, "vkCmdSetCheckpointNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetCheckpointNV);
    } else
    if (std::strcmp(pName, "vkGetQueueCheckpointDataNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetQueueCheckpointDataNV);
    } else
    if (std::strcmp(pName, "vkCmdBindTransformFeedbackBuffersEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindTransformFeedbackBuffersEXT);
    } else
    if (std::strcmp(pName, "vkCmdBeginTransformFeedbackEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginTransformFeedbackEXT);
    } else
    if (std::strcmp(pName, "vkCmdEndTransformFeedbackEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndTransformFeedbackEXT);
    } else
    if (std::strcmp(pName, "vkCmdBeginQueryIndexedEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginQueryIndexedEXT);
    } else
    if (std::strcmp(pName, "vkCmdEndQueryIndexedEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndQueryIndexedEXT);
    } else
    if (std::strcmp(pName, "vkCmdDrawIndirectByteCountEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawIndirectByteCountEXT);
    } else
    if (std::strcmp(pName, "vkCmdSetExclusiveScissorNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetExclusiveScissorNV);
    } else
    if (std::strcmp(pName, "vkCmdBindShadingRateImageNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindShadingRateImageNV);
    } else
    if (std::strcmp(pName, "vkCmdSetViewportShadingRatePaletteNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetViewportShadingRatePaletteNV);
    } else
    if (std::strcmp(pName, "vkCmdSetCoarseSampleOrderNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetCoarseSampleOrderNV);
    } else
    if (std::strcmp(pName, "vkCmdDrawMeshTasksNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawMeshTasksNV);
    } else
    if (std::strcmp(pName, "vkCmdDrawMeshTasksIndirectNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawMeshTasksIndirectNV);
    } else
    if (std::strcmp(pName, "vkCmdDrawMeshTasksIndirectCountNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDrawMeshTasksIndirectCountNV);
    } else
    if (std::strcmp(pName, "vkCompileDeferredNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCompileDeferredNV);
    } else
    if (std::strcmp(pName, "vkCreateAccelerationStructureNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateAccelerationStructureNV);
    } else
    if (std::strcmp(pName, "vkCmdBindInvocationMaskHUAWEI") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindInvocationMaskHUAWEI);
    } else
    if (std::strcmp(pName, "vkDestroyAccelerationStructureKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyAccelerationStructureKHR);
    } else
    if (std::strcmp(pName, "vkDestroyAccelerationStructureNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyAccelerationStructureNV);
    } else
    if (std::strcmp(pName, "vkGetAccelerationStructureMemoryRequirementsNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetAccelerationStructureMemoryRequirementsNV);
    } else
    if (std::strcmp(pName, "vkBindAccelerationStructureMemoryNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBindAccelerationStructureMemoryNV);
    } else
    if (std::strcmp(pName, "vkCmdCopyAccelerationStructureNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyAccelerationStructureNV);
    } else
    if (std::strcmp(pName, "vkCmdCopyAccelerationStructureKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyAccelerationStructureKHR);
    } else
    if (std::strcmp(pName, "vkCopyAccelerationStructureKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCopyAccelerationStructureKHR);
    } else
    if (std::strcmp(pName, "vkCmdCopyAccelerationStructureToMemoryKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyAccelerationStructureToMemoryKHR);
    } else
    if (std::strcmp(pName, "vkCopyAccelerationStructureToMemoryKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCopyAccelerationStructureToMemoryKHR);
    } else
    if (std::strcmp(pName, "vkCmdCopyMemoryToAccelerationStructureKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyMemoryToAccelerationStructureKHR);
    } else
    if (std::strcmp(pName, "vkCopyMemoryToAccelerationStructureKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCopyMemoryToAccelerationStructureKHR);
    } else
    if (std::strcmp(pName, "vkCmdWriteAccelerationStructuresPropertiesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWriteAccelerationStructuresPropertiesKHR);
    } else
    if (std::strcmp(pName, "vkCmdWriteAccelerationStructuresPropertiesNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWriteAccelerationStructuresPropertiesNV);
    } else
    if (std::strcmp(pName, "vkCmdBuildAccelerationStructureNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBuildAccelerationStructureNV);
    } else
    if (std::strcmp(pName, "vkWriteAccelerationStructuresPropertiesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkWriteAccelerationStructuresPropertiesKHR);
    } else
    if (std::strcmp(pName, "vkCmdTraceRaysKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdTraceRaysKHR);
    } else
    if (std::strcmp(pName, "vkCmdTraceRaysNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdTraceRaysNV);
    } else
    if (std::strcmp(pName, "vkGetRayTracingShaderGroupHandlesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetRayTracingShaderGroupHandlesKHR);
    } else
    if (std::strcmp(pName, "vkGetRayTracingShaderGroupHandlesNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetRayTracingShaderGroupHandlesKHR);
    } else
    if (std::strcmp(pName, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetRayTracingCaptureReplayShaderGroupHandlesKHR);
    } else
    if (std::strcmp(pName, "vkGetAccelerationStructureHandleNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetAccelerationStructureHandleNV);
    } else
    if (std::strcmp(pName, "vkCreateRayTracingPipelinesNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateRayTracingPipelinesNV);
    } else
    if (std::strcmp(pName, "vkCreateRayTracingPipelinesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateRayTracingPipelinesKHR);
    } else
    if (std::strcmp(pName, "vkCmdTraceRaysIndirectKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdTraceRaysIndirectKHR);
    } else
    if (std::strcmp(pName, "vkCmdTraceRaysIndirect2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdTraceRaysIndirect2KHR);
    } else
    if (std::strcmp(pName, "vkGetDeviceAccelerationStructureCompatibilityKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceAccelerationStructureCompatibilityKHR);
    } else
    if (std::strcmp(pName, "vkGetRayTracingShaderGroupStackSizeKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetRayTracingShaderGroupStackSizeKHR);
    } else
    if (std::strcmp(pName, "vkCmdSetRayTracingPipelineStackSizeKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetRayTracingPipelineStackSizeKHR);
    } else
    if (std::strcmp(pName, "vkGetImageViewHandleNVX") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageViewHandleNVX);
    } else
    if (std::strcmp(pName, "vkGetImageViewAddressNVX") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageViewAddressNVX);
    } else
    if (std::strcmp(pName, "vkAcquireProfilingLockKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAcquireProfilingLockKHR);
    } else
    if (std::strcmp(pName, "vkReleaseProfilingLockKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkReleaseProfilingLockKHR);
    } else
    if (std::strcmp(pName, "vkGetImageDrmFormatModifierPropertiesEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageDrmFormatModifierPropertiesEXT);
    } else
    if (std::strcmp(pName, "vkGetBufferOpaqueCaptureAddress") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferOpaqueCaptureAddress);
    } else
    if (std::strcmp(pName, "vkGetBufferOpaqueCaptureAddressKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferOpaqueCaptureAddress);
    } else
    if (std::strcmp(pName, "vkGetBufferDeviceAddress") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferDeviceAddress);
    } else
    if (std::strcmp(pName, "vkGetBufferDeviceAddressKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferDeviceAddress);
    } else
    if (std::strcmp(pName, "vkGetBufferDeviceAddressEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferDeviceAddress);
    } else
    if (std::strcmp(pName, "vkInitializePerformanceApiINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkInitializePerformanceApiINTEL);
    } else
    if (std::strcmp(pName, "vkUninitializePerformanceApiINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkUninitializePerformanceApiINTEL);
    } else
    if (std::strcmp(pName, "vkCmdSetPerformanceMarkerINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetPerformanceMarkerINTEL);
    } else
    if (std::strcmp(pName, "vkCmdSetPerformanceStreamMarkerINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetPerformanceStreamMarkerINTEL);
    } else
    if (std::strcmp(pName, "vkCmdSetPerformanceOverrideINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetPerformanceOverrideINTEL);
    } else
    if (std::strcmp(pName, "vkAcquirePerformanceConfigurationINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAcquirePerformanceConfigurationINTEL);
    } else
    if (std::strcmp(pName, "vkReleasePerformanceConfigurationINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkReleasePerformanceConfigurationINTEL);
    } else
    if (std::strcmp(pName, "vkQueueSetPerformanceConfigurationINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueSetPerformanceConfigurationINTEL);
    } else
    if (std::strcmp(pName, "vkGetPerformanceParameterINTEL") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPerformanceParameterINTEL);
    } else
    if (std::strcmp(pName, "vkGetDeviceMemoryOpaqueCaptureAddress") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceMemoryOpaqueCaptureAddress);
    } else
    if (std::strcmp(pName, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeviceMemoryOpaqueCaptureAddress);
    } else
    if (std::strcmp(pName, "vkGetPipelineExecutablePropertiesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPipelineExecutablePropertiesKHR);
    } else
    if (std::strcmp(pName, "vkGetPipelineExecutableStatisticsKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPipelineExecutableStatisticsKHR);
    } else
    if (std::strcmp(pName, "vkGetPipelineExecutableInternalRepresentationsKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPipelineExecutableInternalRepresentationsKHR);
    } else
    if (std::strcmp(pName, "vkCmdSetLineStippleEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetLineStippleEXT);
    } else
    if (std::strcmp(pName, "vkCreateAccelerationStructureKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateAccelerationStructureKHR);
    } else
    if (std::strcmp(pName, "vkCmdBuildAccelerationStructuresKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBuildAccelerationStructuresKHR);
    } else
    if (std::strcmp(pName, "vkCmdBuildAccelerationStructuresIndirectKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBuildAccelerationStructuresIndirectKHR);
    } else
    if (std::strcmp(pName, "vkBuildAccelerationStructuresKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBuildAccelerationStructuresKHR);
    } else
    if (std::strcmp(pName, "vkGetAccelerationStructureDeviceAddressKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetAccelerationStructureDeviceAddressKHR);
    } else
    if (std::strcmp(pName, "vkCreateDeferredOperationKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateDeferredOperationKHR);
    } else
    if (std::strcmp(pName, "vkDestroyDeferredOperationKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyDeferredOperationKHR);
    } else
    if (std::strcmp(pName, "vkGetDeferredOperationMaxConcurrencyKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeferredOperationMaxConcurrencyKHR);
    } else
    if (std::strcmp(pName, "vkGetDeferredOperationResultKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDeferredOperationResultKHR);
    } else
    if (std::strcmp(pName, "vkDeferredOperationJoinKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDeferredOperationJoinKHR);
    } else
    if (std::strcmp(pName, "vkCmdSetCullMode") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetCullMode);
    } else
    if (std::strcmp(pName, "vkCmdSetCullModeEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetCullMode);
    } else
    if (std::strcmp(pName, "vkCmdSetFrontFace") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetFrontFace);
    } else
    if (std::strcmp(pName, "vkCmdSetFrontFaceEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetFrontFace);
    } else
    if (std::strcmp(pName, "vkCmdSetPrimitiveTopology") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetPrimitiveTopology);
    } else
    if (std::strcmp(pName, "vkCmdSetPrimitiveTopologyEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetPrimitiveTopology);
    } else
    if (std::strcmp(pName, "vkCmdSetViewportWithCount") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetViewportWithCount);
    } else
    if (std::strcmp(pName, "vkCmdSetViewportWithCountEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetViewportWithCount);
    } else
    if (std::strcmp(pName, "vkCmdSetScissorWithCount") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetScissorWithCount);
    } else
    if (std::strcmp(pName, "vkCmdSetScissorWithCountEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetScissorWithCount);
    } else
    if (std::strcmp(pName, "vkCmdBindVertexBuffers2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindVertexBuffers2);
    } else
    if (std::strcmp(pName, "vkCmdBindVertexBuffers2EXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBindVertexBuffers2);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthTestEnable") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthTestEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthTestEnableEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthTestEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthWriteEnable") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthWriteEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthWriteEnableEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthWriteEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthCompareOp") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthCompareOp);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthCompareOpEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthCompareOp);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthBoundsTestEnable") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthBoundsTestEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthBoundsTestEnableEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthBoundsTestEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetStencilTestEnable") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetStencilTestEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetStencilTestEnableEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetStencilTestEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetStencilOp") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetStencilOp);
    } else
    if (std::strcmp(pName, "vkCmdSetStencilOpEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetStencilOp);
    } else
    if (std::strcmp(pName, "vkCmdSetPatchControlPointsEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetPatchControlPointsEXT);
    } else
    if (std::strcmp(pName, "vkCmdSetRasterizerDiscardEnable") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetRasterizerDiscardEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetRasterizerDiscardEnableEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetRasterizerDiscardEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthBiasEnable") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthBiasEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetDepthBiasEnableEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetDepthBiasEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetLogicOpEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetLogicOpEXT);
    } else
    if (std::strcmp(pName, "vkCmdSetPrimitiveRestartEnable") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetPrimitiveRestartEnable);
    } else
    if (std::strcmp(pName, "vkCmdSetPrimitiveRestartEnableEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetPrimitiveRestartEnable);
    } else
    if (std::strcmp(pName, "vkCreatePrivateDataSlot") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreatePrivateDataSlot);
    } else
    if (std::strcmp(pName, "vkCreatePrivateDataSlotEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreatePrivateDataSlot);
    } else
    if (std::strcmp(pName, "vkDestroyPrivateDataSlot") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyPrivateDataSlot);
    } else
    if (std::strcmp(pName, "vkDestroyPrivateDataSlotEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyPrivateDataSlot);
    } else
    if (std::strcmp(pName, "vkSetPrivateData") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetPrivateData);
    } else
    if (std::strcmp(pName, "vkSetPrivateDataEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetPrivateData);
    } else
    if (std::strcmp(pName, "vkGetPrivateData") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPrivateData);
    } else
    if (std::strcmp(pName, "vkGetPrivateDataEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPrivateData);
    } else
    if (std::strcmp(pName, "vkCmdCopyBuffer2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyBuffer2);
    } else
    if (std::strcmp(pName, "vkCmdCopyBuffer2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyBuffer2);
    } else
    if (std::strcmp(pName, "vkCmdCopyImage2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyImage2);
    } else
    if (std::strcmp(pName, "vkCmdCopyImage2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyImage2);
    } else
    if (std::strcmp(pName, "vkCmdBlitImage2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBlitImage2);
    } else
    if (std::strcmp(pName, "vkCmdBlitImage2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBlitImage2);
    } else
    if (std::strcmp(pName, "vkCmdCopyBufferToImage2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyBufferToImage2);
    } else
    if (std::strcmp(pName, "vkCmdCopyBufferToImage2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyBufferToImage2);
    } else
    if (std::strcmp(pName, "vkCmdCopyImageToBuffer2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyImageToBuffer2);
    } else
    if (std::strcmp(pName, "vkCmdCopyImageToBuffer2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCopyImageToBuffer2);
    } else
    if (std::strcmp(pName, "vkCmdResolveImage2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdResolveImage2);
    } else
    if (std::strcmp(pName, "vkCmdResolveImage2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdResolveImage2);
    } else
    if (std::strcmp(pName, "vkCmdSetFragmentShadingRateKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetFragmentShadingRateKHR);
    } else
    if (std::strcmp(pName, "vkCmdSetFragmentShadingRateEnumNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetFragmentShadingRateEnumNV);
    } else
    if (std::strcmp(pName, "vkGetAccelerationStructureBuildSizesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetAccelerationStructureBuildSizesKHR);
    } else
    if (std::strcmp(pName, "vkCmdSetVertexInputEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetVertexInputEXT);
    } else
    if (std::strcmp(pName, "vkCmdSetColorWriteEnableEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetColorWriteEnableEXT);
    } else
    if (std::strcmp(pName, "vkCmdSetEvent2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetEvent2);
    } else
    if (std::strcmp(pName, "vkCmdSetEvent2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdSetEvent2);
    } else
    if (std::strcmp(pName, "vkCmdResetEvent2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdResetEvent2);
    } else
    if (std::strcmp(pName, "vkCmdResetEvent2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdResetEvent2);
    } else
    if (std::strcmp(pName, "vkCmdWaitEvents2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWaitEvents2);
    } else
    if (std::strcmp(pName, "vkCmdWaitEvents2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWaitEvents2);
    } else
    if (std::strcmp(pName, "vkCmdPipelineBarrier2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdPipelineBarrier2);
    } else
    if (std::strcmp(pName, "vkCmdPipelineBarrier2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdPipelineBarrier2);
    } else
    if (std::strcmp(pName, "vkQueueSubmit2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueSubmit2);
    } else
    if (std::strcmp(pName, "vkQueueSubmit2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueSubmit2);
    } else
    if (std::strcmp(pName, "vkCmdWriteTimestamp2") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWriteTimestamp2);
    } else
    if (std::strcmp(pName, "vkCmdWriteTimestamp2KHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWriteTimestamp2);
    } else
    if (std::strcmp(pName, "vkCmdWriteBufferMarker2AMD") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdWriteBufferMarker2AMD);
    } else
    if (std::strcmp(pName, "vkGetQueueCheckpointData2NV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetQueueCheckpointData2NV);
    } else
    if (std::strcmp(pName, "vkCreateCuModuleNVX") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateCuModuleNVX);
    } else
    if (std::strcmp(pName, "vkCreateCuFunctionNVX") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateCuFunctionNVX);
    } else
    if (std::strcmp(pName, "vkDestroyCuModuleNVX") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyCuModuleNVX);
    } else
    if (std::strcmp(pName, "vkDestroyCuFunctionNVX") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyCuFunctionNVX);
    } else
    if (std::strcmp(pName, "vkCmdCuLaunchKernelNVX") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdCuLaunchKernelNVX);
    } else
    if (std::strcmp(pName, "vkSetDeviceMemoryPriorityEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetDeviceMemoryPriorityEXT);
    } else
    if (std::strcmp(pName, "vkWaitForPresentKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkWaitForPresentKHR);
    } else
    if (std::strcmp(pName, "vkCmdBeginRendering") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginRendering);
    } else
    if (std::strcmp(pName, "vkCmdBeginRenderingKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginRendering);
    } else
    if (std::strcmp(pName, "vkCmdEndRendering") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndRendering);
    } else
    if (std::strcmp(pName, "vkCmdEndRenderingKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndRendering);
    } else
    if (std::strcmp(pName, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDescriptorSetLayoutHostMappingInfoVALVE);
    } else
    if (std::strcmp(pName, "vkGetDescriptorSetHostMappingVALVE") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetDescriptorSetHostMappingVALVE);
    } else
    if (std::strcmp(pName, "vkGetImageSubresourceLayout2EXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetImageSubresourceLayout2EXT);
    } else
    if (std::strcmp(pName, "vkGetPipelinePropertiesEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetPipelinePropertiesEXT);
    } else
#if defined(VK_USE_PLATFORM_ANDROID_KHR)

    if (std::strcmp(pName, "vkGetSwapchainGrallocUsageANDROID") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSwapchainGrallocUsageANDROID);
    } else
    if (std::strcmp(pName, "vkGetSwapchainGrallocUsage2ANDROID") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSwapchainGrallocUsage2ANDROID);
    } else
    if (std::strcmp(pName, "vkAcquireImageANDROID") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAcquireImageANDROID);
    } else
    if (std::strcmp(pName, "vkQueueSignalReleaseImageANDROID") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkQueueSignalReleaseImageANDROID);
    } else
    if (std::strcmp(pName, "vkGetAndroidHardwareBufferPropertiesANDROID") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetAndroidHardwareBufferPropertiesANDROID);
    } else
    if (std::strcmp(pName, "vkGetMemoryAndroidHardwareBufferANDROID") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryAndroidHardwareBufferANDROID);
    } else
#endif // defined(VK_USE_PLATFORM_ANDROID_KHR)

#if defined(VK_USE_PLATFORM_DIRECTFB_EXT)

#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT)

#if defined(VK_USE_PLATFORM_FUCHSIA)

    if (std::strcmp(pName, "vkGetMemoryZirconHandleFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryZirconHandleFUCHSIA);
    } else
    if (std::strcmp(pName, "vkGetMemoryZirconHandlePropertiesFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryZirconHandlePropertiesFUCHSIA);
    } else
    if (std::strcmp(pName, "vkGetSemaphoreZirconHandleFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSemaphoreZirconHandleFUCHSIA);
    } else
    if (std::strcmp(pName, "vkImportSemaphoreZirconHandleFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkImportSemaphoreZirconHandleFUCHSIA);
    } else
    if (std::strcmp(pName, "vkCreateBufferCollectionFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateBufferCollectionFUCHSIA);
    } else
    if (std::strcmp(pName, "vkSetBufferCollectionBufferConstraintsFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetBufferCollectionBufferConstraintsFUCHSIA);
    } else
    if (std::strcmp(pName, "vkSetBufferCollectionImageConstraintsFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkSetBufferCollectionImageConstraintsFUCHSIA);
    } else
    if (std::strcmp(pName, "vkDestroyBufferCollectionFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyBufferCollectionFUCHSIA);
    } else
    if (std::strcmp(pName, "vkGetBufferCollectionPropertiesFUCHSIA") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetBufferCollectionPropertiesFUCHSIA);
    } else
#endif // defined(VK_USE_PLATFORM_FUCHSIA)

#if defined(VK_USE_PLATFORM_GGP)

#endif // defined(VK_USE_PLATFORM_GGP)

#if defined(VK_USE_PLATFORM_IOS_MVK)

#endif // defined(VK_USE_PLATFORM_IOS_MVK)

#if defined(VK_USE_PLATFORM_MACOS_MVK)

#endif // defined(VK_USE_PLATFORM_MACOS_MVK)

#if defined(VK_USE_PLATFORM_METAL_EXT)

    if (std::strcmp(pName, "vkExportMetalObjectsEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkExportMetalObjectsEXT);
    } else
#endif // defined(VK_USE_PLATFORM_METAL_EXT)

#if defined(VK_ENABLE_BETA_EXTENSIONS)

    if (std::strcmp(pName, "vkCreateVideoSessionKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateVideoSessionKHR);
    } else
    if (std::strcmp(pName, "vkDestroyVideoSessionKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyVideoSessionKHR);
    } else
    if (std::strcmp(pName, "vkCreateVideoSessionParametersKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCreateVideoSessionParametersKHR);
    } else
    if (std::strcmp(pName, "vkUpdateVideoSessionParametersKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkUpdateVideoSessionParametersKHR);
    } else
    if (std::strcmp(pName, "vkDestroyVideoSessionParametersKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkDestroyVideoSessionParametersKHR);
    } else
    if (std::strcmp(pName, "vkGetVideoSessionMemoryRequirementsKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetVideoSessionMemoryRequirementsKHR);
    } else
    if (std::strcmp(pName, "vkBindVideoSessionMemoryKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkBindVideoSessionMemoryKHR);
    } else
    if (std::strcmp(pName, "vkCmdDecodeVideoKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdDecodeVideoKHR);
    } else
    if (std::strcmp(pName, "vkCmdBeginVideoCodingKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdBeginVideoCodingKHR);
    } else
    if (std::strcmp(pName, "vkCmdControlVideoCodingKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdControlVideoCodingKHR);
    } else
    if (std::strcmp(pName, "vkCmdEndVideoCodingKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEndVideoCodingKHR);
    } else
    if (std::strcmp(pName, "vkCmdEncodeVideoKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkCmdEncodeVideoKHR);
    } else
#endif // defined(VK_ENABLE_BETA_EXTENSIONS)

#if defined(VK_USE_PLATFORM_SCREEN_QNX)

#endif // defined(VK_USE_PLATFORM_SCREEN_QNX)

#if defined(VK_USE_PLATFORM_VI_NN)

#endif // defined(VK_USE_PLATFORM_VI_NN)

#if defined(VK_USE_PLATFORM_WAYLAND_KHR)

#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR)

#if defined(VK_USE_PLATFORM_WIN32_KHR)

    if (std::strcmp(pName, "vkGetMemoryWin32HandleNV") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryWin32HandleNV);
    } else
    if (std::strcmp(pName, "vkGetMemoryWin32HandleKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryWin32HandleKHR);
    } else
    if (std::strcmp(pName, "vkGetMemoryWin32HandlePropertiesKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetMemoryWin32HandlePropertiesKHR);
    } else
    if (std::strcmp(pName, "vkGetSemaphoreWin32HandleKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetSemaphoreWin32HandleKHR);
    } else
    if (std::strcmp(pName, "vkImportSemaphoreWin32HandleKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkImportSemaphoreWin32HandleKHR);
    } else
    if (std::strcmp(pName, "vkGetFenceWin32HandleKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkGetFenceWin32HandleKHR);
    } else
    if (std::strcmp(pName, "vkImportFenceWin32HandleKHR") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkImportFenceWin32HandleKHR);
    } else
    if (std::strcmp(pName, "vkAcquireFullScreenExclusiveModeEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkAcquireFullScreenExclusiveModeEXT);
    } else
    if (std::strcmp(pName, "vkReleaseFullScreenExclusiveModeEXT") == 0) {
        return reinterpret_cast<PFN_vkVoidFunction>(&vkReleaseFullScreenExclusiveModeEXT);
    } else
#endif // defined(VK_USE_PLATFORM_WIN32_KHR)

#if defined(VK_USE_PLATFORM_XCB_KHR)

#endif // defined(VK_USE_PLATFORM_XCB_KHR)

#if defined(VK_USE_PLATFORM_XLIB_KHR)

#endif // defined(VK_USE_PLATFORM_XLIB_KHR)

#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)

#endif // defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT)

        {{
            return nullptr;
        }}
}
} // namespace vk_capture