text: /*
  ** Copyright (c) 2018-2021 Valve Corporation
  ** Copyright (c) 2018-2021 LunarG, Inc.
  **
  ** Permission is hereby granted, free of charge, to any person obtaining a
  ** copy of this software and associated documentation files (the "Software"),
  ** to deal in the Software without restriction, including without limitation
  ** the rights to use, copy, modify, merge, publish, distribute, sublicense,
  ** and/or sell copies of the Software, and to permit persons to whom the
  ** Software is furnished to do so, subject to the following conditions:
  **
  ** The above copyright notice and this permission notice shall be included in
  ** all copies or substantial portions of the Software.
  **
  ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  ** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  ** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  ** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  ** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  ** FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  ** DEALINGS IN THE SOFTWARE.
  */
  
  /*
  ** This file is generated from the Khronos Vulkan XML API Registry.
  **
  */
  
  #ifndef  GFXRECON_GENERATED_VULKAN_API_CALL_ENCODERS_H
  #define  GFXRECON_GENERATED_VULKAN_API_CALL_ENCODERS_H
  
  #include "format/platform_types.h"
  #include "util/defines.h"
  
  #include "vulkan/vulkan.h"
  
  GFXRECON_BEGIN_NAMESPACE(gfxrecon)
  GFXRECON_BEGIN_NAMESPACE(encode)
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
      const VkInstanceCreateInfo*                 pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkInstance*                                 pInstance);
  
  VKAPI_ATTR void VKAPI_CALL DestroyInstance(
      VkInstance                                  instance,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
      VkInstance                                  instance,
      uint32_t*                                   pPhysicalDeviceCount,
      VkPhysicalDevice*                           pPhysicalDevices);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceFeatures*                   pFeatures);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(
      VkPhysicalDevice                            physicalDevice,
      VkFormat                                    format,
      VkFormatProperties*                         pFormatProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
      VkPhysicalDevice                            physicalDevice,
      VkFormat                                    format,
      VkImageType                                 type,
      VkImageTiling                               tiling,
      VkImageUsageFlags                           usage,
      VkImageCreateFlags                          flags,
      VkImageFormatProperties*                    pImageFormatProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceProperties*                 pProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pQueueFamilyPropertyCount,
      VkQueueFamilyProperties*                    pQueueFamilyProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
      VkPhysicalDevice                            physicalDevice,
      const VkDeviceCreateInfo*                   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDevice*                                   pDevice);
  
  VKAPI_ATTR void VKAPI_CALL DestroyDevice(
      VkDevice                                    device,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
      VkDevice                                    device,
      uint32_t                                    queueFamilyIndex,
      uint32_t                                    queueIndex,
      VkQueue*                                    pQueue);
  
  VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
      VkQueue                                     queue,
      uint32_t                                    submitCount,
      const VkSubmitInfo*                         pSubmits,
      VkFence                                     fence);
  
  VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
      VkQueue                                     queue);
  
  VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
      VkDevice                                    device);
  
  VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
      VkDevice                                    device,
      const VkMemoryAllocateInfo*                 pAllocateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDeviceMemory*                             pMemory);
  
  VKAPI_ATTR void VKAPI_CALL FreeMemory(
      VkDevice                                    device,
      VkDeviceMemory                              memory,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
      VkDevice                                    device,
      VkDeviceMemory                              memory,
      VkDeviceSize                                offset,
      VkDeviceSize                                size,
      VkMemoryMapFlags                            flags,
      void**                                      ppData);
  
  VKAPI_ATTR void VKAPI_CALL UnmapMemory(
      VkDevice                                    device,
      VkDeviceMemory                              memory);
  
  VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
      VkDevice                                    device,
      uint32_t                                    memoryRangeCount,
      const VkMappedMemoryRange*                  pMemoryRanges);
  
  VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
      VkDevice                                    device,
      uint32_t                                    memoryRangeCount,
      const VkMappedMemoryRange*                  pMemoryRanges);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
      VkDevice                                    device,
      VkDeviceMemory                              memory,
      VkDeviceSize*                               pCommittedMemoryInBytes);
  
  VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
      VkDevice                                    device,
      VkBuffer                                    buffer,
      VkDeviceMemory                              memory,
      VkDeviceSize                                memoryOffset);
  
  VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
      VkDevice                                    device,
      VkImage                                     image,
      VkDeviceMemory                              memory,
      VkDeviceSize                                memoryOffset);
  
  VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
      VkDevice                                    device,
      VkBuffer                                    buffer,
      VkMemoryRequirements*                       pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
      VkDevice                                    device,
      VkImage                                     image,
      VkMemoryRequirements*                       pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
      VkDevice                                    device,
      VkImage                                     image,
      uint32_t*                                   pSparseMemoryRequirementCount,
      VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(
      VkPhysicalDevice                            physicalDevice,
      VkFormat                                    format,
      VkImageType                                 type,
      VkSampleCountFlagBits                       samples,
      VkImageUsageFlags                           usage,
      VkImageTiling                               tiling,
      uint32_t*                                   pPropertyCount,
      VkSparseImageFormatProperties*              pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
      VkQueue                                     queue,
      uint32_t                                    bindInfoCount,
      const VkBindSparseInfo*                     pBindInfo,
      VkFence                                     fence);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
      VkDevice                                    device,
      const VkFenceCreateInfo*                    pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkFence*                                    pFence);
  
  VKAPI_ATTR void VKAPI_CALL DestroyFence(
      VkDevice                                    device,
      VkFence                                     fence,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
      VkDevice                                    device,
      uint32_t                                    fenceCount,
      const VkFence*                              pFences);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
      VkDevice                                    device,
      VkFence                                     fence);
  
  VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
      VkDevice                                    device,
      uint32_t                                    fenceCount,
      const VkFence*                              pFences,
      VkBool32                                    waitAll,
      uint64_t                                    timeout);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
      VkDevice                                    device,
      const VkSemaphoreCreateInfo*                pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSemaphore*                                pSemaphore);
  
  VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
      VkDevice                                    device,
      VkSemaphore                                 semaphore,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
      VkDevice                                    device,
      const VkEventCreateInfo*                    pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkEvent*                                    pEvent);
  
  VKAPI_ATTR void VKAPI_CALL DestroyEvent(
      VkDevice                                    device,
      VkEvent                                     event,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
      VkDevice                                    device,
      VkEvent                                     event);
  
  VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
      VkDevice                                    device,
      VkEvent                                     event);
  
  VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
      VkDevice                                    device,
      VkEvent                                     event);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
      VkDevice                                    device,
      const VkQueryPoolCreateInfo*                pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkQueryPool*                                pQueryPool);
  
  VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
      VkDevice                                    device,
      VkQueryPool                                 queryPool,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
      VkDevice                                    device,
      VkQueryPool                                 queryPool,
      uint32_t                                    firstQuery,
      uint32_t                                    queryCount,
      size_t                                      dataSize,
      void*                                       pData,
      VkDeviceSize                                stride,
      VkQueryResultFlags                          flags);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
      VkDevice                                    device,
      const VkBufferCreateInfo*                   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkBuffer*                                   pBuffer);
  
  VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
      VkDevice                                    device,
      VkBuffer                                    buffer,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
      VkDevice                                    device,
      const VkBufferViewCreateInfo*               pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkBufferView*                               pView);
  
  VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
      VkDevice                                    device,
      VkBufferView                                bufferView,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
      VkDevice                                    device,
      const VkImageCreateInfo*                    pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkImage*                                    pImage);
  
  VKAPI_ATTR void VKAPI_CALL DestroyImage(
      VkDevice                                    device,
      VkImage                                     image,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
      VkDevice                                    device,
      VkImage                                     image,
      const VkImageSubresource*                   pSubresource,
      VkSubresourceLayout*                        pLayout);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
      VkDevice                                    device,
      const VkImageViewCreateInfo*                pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkImageView*                                pView);
  
  VKAPI_ATTR void VKAPI_CALL DestroyImageView(
      VkDevice                                    device,
      VkImageView                                 imageView,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
      VkDevice                                    device,
      const VkShaderModuleCreateInfo*             pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkShaderModule*                             pShaderModule);
  
  VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
      VkDevice                                    device,
      VkShaderModule                              shaderModule,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
      VkDevice                                    device,
      const VkPipelineCacheCreateInfo*            pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkPipelineCache*                            pPipelineCache);
  
  VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      size_t*                                     pDataSize,
      void*                                       pData);
  
  VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
      VkDevice                                    device,
      VkPipelineCache                             dstCache,
      uint32_t                                    srcCacheCount,
      const VkPipelineCache*                      pSrcCaches);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      uint32_t                                    createInfoCount,
      const VkGraphicsPipelineCreateInfo*         pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkPipeline*                                 pPipelines);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      uint32_t                                    createInfoCount,
      const VkComputePipelineCreateInfo*          pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkPipeline*                                 pPipelines);
  
  VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
      VkDevice                                    device,
      const VkPipelineLayoutCreateInfo*           pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkPipelineLayout*                           pPipelineLayout);
  
  VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
      VkDevice                                    device,
      VkPipelineLayout                            pipelineLayout,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
      VkDevice                                    device,
      const VkSamplerCreateInfo*                  pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSampler*                                  pSampler);
  
  VKAPI_ATTR void VKAPI_CALL DestroySampler(
      VkDevice                                    device,
      VkSampler                                   sampler,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
      VkDevice                                    device,
      const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDescriptorSetLayout*                      pSetLayout);
  
  VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
      VkDevice                                    device,
      VkDescriptorSetLayout                       descriptorSetLayout,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
      VkDevice                                    device,
      const VkDescriptorPoolCreateInfo*           pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDescriptorPool*                           pDescriptorPool);
  
  VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
      VkDevice                                    device,
      VkDescriptorPool                            descriptorPool,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
      VkDevice                                    device,
      VkDescriptorPool                            descriptorPool,
      VkDescriptorPoolResetFlags                  flags);
  
  VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
      VkDevice                                    device,
      const VkDescriptorSetAllocateInfo*          pAllocateInfo,
      VkDescriptorSet*                            pDescriptorSets);
  
  VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
      VkDevice                                    device,
      VkDescriptorPool                            descriptorPool,
      uint32_t                                    descriptorSetCount,
      const VkDescriptorSet*                      pDescriptorSets);
  
  VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
      VkDevice                                    device,
      uint32_t                                    descriptorWriteCount,
      const VkWriteDescriptorSet*                 pDescriptorWrites,
      uint32_t                                    descriptorCopyCount,
      const VkCopyDescriptorSet*                  pDescriptorCopies);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
      VkDevice                                    device,
      const VkFramebufferCreateInfo*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkFramebuffer*                              pFramebuffer);
  
  VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
      VkDevice                                    device,
      VkFramebuffer                               framebuffer,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
      VkDevice                                    device,
      const VkRenderPassCreateInfo*               pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkRenderPass*                               pRenderPass);
  
  VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
      VkDevice                                    device,
      VkRenderPass                                renderPass,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
      VkDevice                                    device,
      VkRenderPass                                renderPass,
      VkExtent2D*                                 pGranularity);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
      VkDevice                                    device,
      const VkCommandPoolCreateInfo*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkCommandPool*                              pCommandPool);
  
  VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
      VkDevice                                    device,
      VkCommandPool                               commandPool,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
      VkDevice                                    device,
      VkCommandPool                               commandPool,
      VkCommandPoolResetFlags                     flags);
  
  VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
      VkDevice                                    device,
      const VkCommandBufferAllocateInfo*          pAllocateInfo,
      VkCommandBuffer*                            pCommandBuffers);
  
  VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
      VkDevice                                    device,
      VkCommandPool                               commandPool,
      uint32_t                                    commandBufferCount,
      const VkCommandBuffer*                      pCommandBuffers);
  
  VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
      VkCommandBuffer                             commandBuffer,
      const VkCommandBufferBeginInfo*             pBeginInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
      VkCommandBuffer                             commandBuffer);
  
  VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
      VkCommandBuffer                             commandBuffer,
      VkCommandBufferResetFlags                   flags);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
      VkCommandBuffer                             commandBuffer,
      VkPipelineBindPoint                         pipelineBindPoint,
      VkPipeline                                  pipeline);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstViewport,
      uint32_t                                    viewportCount,
      const VkViewport*                           pViewports);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstScissor,
      uint32_t                                    scissorCount,
      const VkRect2D*                             pScissors);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
      VkCommandBuffer                             commandBuffer,
      float                                       lineWidth);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
      VkCommandBuffer                             commandBuffer,
      float                                       depthBiasConstantFactor,
      float                                       depthBiasClamp,
      float                                       depthBiasSlopeFactor);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
      VkCommandBuffer                             commandBuffer,
      const float                                 blendConstants[4]);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
      VkCommandBuffer                             commandBuffer,
      float                                       minDepthBounds,
      float                                       maxDepthBounds);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
      VkCommandBuffer                             commandBuffer,
      VkStencilFaceFlags                          faceMask,
      uint32_t                                    compareMask);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
      VkCommandBuffer                             commandBuffer,
      VkStencilFaceFlags                          faceMask,
      uint32_t                                    writeMask);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
      VkCommandBuffer                             commandBuffer,
      VkStencilFaceFlags                          faceMask,
      uint32_t                                    reference);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
      VkCommandBuffer                             commandBuffer,
      VkPipelineBindPoint                         pipelineBindPoint,
      VkPipelineLayout                            layout,
      uint32_t                                    firstSet,
      uint32_t                                    descriptorSetCount,
      const VkDescriptorSet*                      pDescriptorSets,
      uint32_t                                    dynamicOffsetCount,
      const uint32_t*                             pDynamicOffsets);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      VkIndexType                                 indexType);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstBinding,
      uint32_t                                    bindingCount,
      const VkBuffer*                             pBuffers,
      const VkDeviceSize*                         pOffsets);
  
  VKAPI_ATTR void VKAPI_CALL CmdDraw(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    vertexCount,
      uint32_t                                    instanceCount,
      uint32_t                                    firstVertex,
      uint32_t                                    firstInstance);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    indexCount,
      uint32_t                                    instanceCount,
      uint32_t                                    firstIndex,
      int32_t                                     vertexOffset,
      uint32_t                                    firstInstance);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      uint32_t                                    drawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      uint32_t                                    drawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdDispatch(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    groupCountX,
      uint32_t                                    groupCountY,
      uint32_t                                    groupCountZ);
  
  VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    srcBuffer,
      VkBuffer                                    dstBuffer,
      uint32_t                                    regionCount,
      const VkBufferCopy*                         pRegions);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
      VkCommandBuffer                             commandBuffer,
      VkImage                                     srcImage,
      VkImageLayout                               srcImageLayout,
      VkImage                                     dstImage,
      VkImageLayout                               dstImageLayout,
      uint32_t                                    regionCount,
      const VkImageCopy*                          pRegions);
  
  VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
      VkCommandBuffer                             commandBuffer,
      VkImage                                     srcImage,
      VkImageLayout                               srcImageLayout,
      VkImage                                     dstImage,
      VkImageLayout                               dstImageLayout,
      uint32_t                                    regionCount,
      const VkImageBlit*                          pRegions,
      VkFilter                                    filter);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    srcBuffer,
      VkImage                                     dstImage,
      VkImageLayout                               dstImageLayout,
      uint32_t                                    regionCount,
      const VkBufferImageCopy*                    pRegions);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
      VkCommandBuffer                             commandBuffer,
      VkImage                                     srcImage,
      VkImageLayout                               srcImageLayout,
      VkBuffer                                    dstBuffer,
      uint32_t                                    regionCount,
      const VkBufferImageCopy*                    pRegions);
  
  VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    dstBuffer,
      VkDeviceSize                                dstOffset,
      VkDeviceSize                                dataSize,
      const void*                                 pData);
  
  VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    dstBuffer,
      VkDeviceSize                                dstOffset,
      VkDeviceSize                                size,
      uint32_t                                    data);
  
  VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
      VkCommandBuffer                             commandBuffer,
      VkImage                                     image,
      VkImageLayout                               imageLayout,
      const VkClearColorValue*                    pColor,
      uint32_t                                    rangeCount,
      const VkImageSubresourceRange*              pRanges);
  
  VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
      VkCommandBuffer                             commandBuffer,
      VkImage                                     image,
      VkImageLayout                               imageLayout,
      const VkClearDepthStencilValue*             pDepthStencil,
      uint32_t                                    rangeCount,
      const VkImageSubresourceRange*              pRanges);
  
  VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    attachmentCount,
      const VkClearAttachment*                    pAttachments,
      uint32_t                                    rectCount,
      const VkClearRect*                          pRects);
  
  VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
      VkCommandBuffer                             commandBuffer,
      VkImage                                     srcImage,
      VkImageLayout                               srcImageLayout,
      VkImage                                     dstImage,
      VkImageLayout                               dstImageLayout,
      uint32_t                                    regionCount,
      const VkImageResolve*                       pRegions);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
      VkCommandBuffer                             commandBuffer,
      VkEvent                                     event,
      VkPipelineStageFlags                        stageMask);
  
  VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
      VkCommandBuffer                             commandBuffer,
      VkEvent                                     event,
      VkPipelineStageFlags                        stageMask);
  
  VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
      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);
  
  VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
      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);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
      VkCommandBuffer                             commandBuffer,
      VkQueryPool                                 queryPool,
      uint32_t                                    query,
      VkQueryControlFlags                         flags);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
      VkCommandBuffer                             commandBuffer,
      VkQueryPool                                 queryPool,
      uint32_t                                    query);
  
  VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
      VkCommandBuffer                             commandBuffer,
      VkQueryPool                                 queryPool,
      uint32_t                                    firstQuery,
      uint32_t                                    queryCount);
  
  VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
      VkCommandBuffer                             commandBuffer,
      VkPipelineStageFlagBits                     pipelineStage,
      VkQueryPool                                 queryPool,
      uint32_t                                    query);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
      VkCommandBuffer                             commandBuffer,
      VkQueryPool                                 queryPool,
      uint32_t                                    firstQuery,
      uint32_t                                    queryCount,
      VkBuffer                                    dstBuffer,
      VkDeviceSize                                dstOffset,
      VkDeviceSize                                stride,
      VkQueryResultFlags                          flags);
  
  VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
      VkCommandBuffer                             commandBuffer,
      VkPipelineLayout                            layout,
      VkShaderStageFlags                          stageFlags,
      uint32_t                                    offset,
      uint32_t                                    size,
      const void*                                 pValues);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
      VkCommandBuffer                             commandBuffer,
      const VkRenderPassBeginInfo*                pRenderPassBegin,
      VkSubpassContents                           contents);
  
  VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
      VkCommandBuffer                             commandBuffer,
      VkSubpassContents                           contents);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
      VkCommandBuffer                             commandBuffer);
  
  VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    commandBufferCount,
      const VkCommandBuffer*                      pCommandBuffers);
  
  VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindBufferMemoryInfo*               pBindInfos);
  
  VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindImageMemoryInfo*                pBindInfos);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(
      VkDevice                                    device,
      uint32_t                                    heapIndex,
      uint32_t                                    localDeviceIndex,
      uint32_t                                    remoteDeviceIndex,
      VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    deviceMask);
  
  VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    baseGroupX,
      uint32_t                                    baseGroupY,
      uint32_t                                    baseGroupZ,
      uint32_t                                    groupCountX,
      uint32_t                                    groupCountY,
      uint32_t                                    groupCountZ);
  
  VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
      VkInstance                                  instance,
      uint32_t*                                   pPhysicalDeviceGroupCount,
      VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(
      VkDevice                                    device,
      const VkImageMemoryRequirementsInfo2*       pInfo,
      VkMemoryRequirements2*                      pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(
      VkDevice                                    device,
      const VkBufferMemoryRequirementsInfo2*      pInfo,
      VkMemoryRequirements2*                      pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(
      VkDevice                                    device,
      const VkImageSparseMemoryRequirementsInfo2* pInfo,
      uint32_t*                                   pSparseMemoryRequirementCount,
      VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceFeatures2*                  pFeatures);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceProperties2*                pProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(
      VkPhysicalDevice                            physicalDevice,
      VkFormat                                    format,
      VkFormatProperties2*                        pFormatProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
      VkImageFormatProperties2*                   pImageFormatProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pQueueFamilyPropertyCount,
      VkQueueFamilyProperties2*                   pQueueFamilyProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
      uint32_t*                                   pPropertyCount,
      VkSparseImageFormatProperties2*             pProperties);
  
  VKAPI_ATTR void VKAPI_CALL TrimCommandPool(
      VkDevice                                    device,
      VkCommandPool                               commandPool,
      VkCommandPoolTrimFlags                      flags);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(
      VkDevice                                    device,
      const VkDeviceQueueInfo2*                   pQueueInfo,
      VkQueue*                                    pQueue);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(
      VkDevice                                    device,
      const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSamplerYcbcrConversion*                   pYcbcrConversion);
  
  VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(
      VkDevice                                    device,
      VkSamplerYcbcrConversion                    ycbcrConversion,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(
      VkDevice                                    device,
      const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
  
  VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(
      VkDevice                                    device,
      VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
      VkExternalBufferProperties*                 pExternalBufferProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
      VkExternalFenceProperties*                  pExternalFenceProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
      VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(
      VkDevice                                    device,
      const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
      VkDescriptorSetLayoutSupport*               pSupport);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      VkBuffer                                    countBuffer,
      VkDeviceSize                                countBufferOffset,
      uint32_t                                    maxDrawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      VkBuffer                                    countBuffer,
      VkDeviceSize                                countBufferOffset,
      uint32_t                                    maxDrawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(
      VkDevice                                    device,
      const VkRenderPassCreateInfo2*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkRenderPass*                               pRenderPass);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(
      VkCommandBuffer                             commandBuffer,
      const VkRenderPassBeginInfo*                pRenderPassBegin,
      const VkSubpassBeginInfo*                   pSubpassBeginInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(
      VkCommandBuffer                             commandBuffer,
      const VkSubpassBeginInfo*                   pSubpassBeginInfo,
      const VkSubpassEndInfo*                     pSubpassEndInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(
      VkCommandBuffer                             commandBuffer,
      const VkSubpassEndInfo*                     pSubpassEndInfo);
  
  VKAPI_ATTR void VKAPI_CALL ResetQueryPool(
      VkDevice                                    device,
      VkQueryPool                                 queryPool,
      uint32_t                                    firstQuery,
      uint32_t                                    queryCount);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(
      VkDevice                                    device,
      VkSemaphore                                 semaphore,
      uint64_t*                                   pValue);
  
  VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(
      VkDevice                                    device,
      const VkSemaphoreWaitInfo*                  pWaitInfo,
      uint64_t                                    timeout);
  
  VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(
      VkDevice                                    device,
      const VkSemaphoreSignalInfo*                pSignalInfo);
  
  VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(
      VkDevice                                    device,
      const VkBufferDeviceAddressInfo*            pInfo);
  
  VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(
      VkDevice                                    device,
      const VkBufferDeviceAddressInfo*            pInfo);
  
  VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(
      VkDevice                                    device,
      const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
  
  VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
      VkInstance                                  instance,
      VkSurfaceKHR                                surface,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      VkSurfaceKHR                                surface,
      VkBool32*                                   pSupported);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      uint32_t*                                   pSurfaceFormatCount,
      VkSurfaceFormatKHR*                         pSurfaceFormats);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      uint32_t*                                   pPresentModeCount,
      VkPresentModeKHR*                           pPresentModes);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
      VkDevice                                    device,
      const VkSwapchainCreateInfoKHR*             pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSwapchainKHR*                             pSwapchain);
  
  VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      uint32_t*                                   pSwapchainImageCount,
      VkImage*                                    pSwapchainImages);
  
  VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      uint64_t                                    timeout,
      VkSemaphore                                 semaphore,
      VkFence                                     fence,
      uint32_t*                                   pImageIndex);
  
  VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
      VkQueue                                     queue,
      const VkPresentInfoKHR*                     pPresentInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR(
      VkDevice                                    device,
      VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(
      VkDevice                                    device,
      VkSurfaceKHR                                surface,
      VkDeviceGroupPresentModeFlagsKHR*           pModes);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      uint32_t*                                   pRectCount,
      VkRect2D*                                   pRects);
  
  VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(
      VkDevice                                    device,
      const VkAcquireNextImageInfoKHR*            pAcquireInfo,
      uint32_t*                                   pImageIndex);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkDisplayPropertiesKHR*                     pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkDisplayPlanePropertiesKHR*                pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    planeIndex,
      uint32_t*                                   pDisplayCount,
      VkDisplayKHR*                               pDisplays);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display,
      uint32_t*                                   pPropertyCount,
      VkDisplayModePropertiesKHR*                 pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display,
      const VkDisplayModeCreateInfoKHR*           pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDisplayModeKHR*                           pMode);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayModeKHR                            mode,
      uint32_t                                    planeIndex,
      VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
      VkInstance                                  instance,
      const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
      VkDevice                                    device,
      uint32_t                                    swapchainCount,
      const VkSwapchainCreateInfoKHR*             pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkSwapchainKHR*                             pSwapchains);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
      VkInstance                                  instance,
      const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      Display*                                    dpy,
      VisualID                                    visualID);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
      VkInstance                                  instance,
      const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      xcb_connection_t*                           connection,
      xcb_visualid_t                              visual_id);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
      VkInstance                                  instance,
      const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      struct wl_display*                          display);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
      VkInstance                                  instance,
      const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
      VkInstance                                  instance,
      const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR(
      VkCommandBuffer                             commandBuffer,
      const VkRenderingInfoKHR*                   pRenderingInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR(
      VkCommandBuffer                             commandBuffer);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceFeatures2*                  pFeatures);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceProperties2*                pProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      VkFormat                                    format,
      VkFormatProperties2*                        pFormatProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
      VkImageFormatProperties2*                   pImageFormatProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pQueueFamilyPropertyCount,
      VkQueueFamilyProperties2*                   pQueueFamilyProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
      uint32_t*                                   pPropertyCount,
      VkSparseImageFormatProperties2*             pProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(
      VkDevice                                    device,
      uint32_t                                    heapIndex,
      uint32_t                                    localDeviceIndex,
      uint32_t                                    remoteDeviceIndex,
      VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    deviceMask);
  
  VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    baseGroupX,
      uint32_t                                    baseGroupY,
      uint32_t                                    baseGroupZ,
      uint32_t                                    groupCountX,
      uint32_t                                    groupCountY,
      uint32_t                                    groupCountZ);
  
  VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
      VkDevice                                    device,
      VkCommandPool                               commandPool,
      VkCommandPoolTrimFlags                      flags);
  
  VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
      VkInstance                                  instance,
      uint32_t*                                   pPhysicalDeviceGroupCount,
      VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
      VkExternalBufferProperties*                 pExternalBufferProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
      VkDevice                                    device,
      const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
      HANDLE*                                     pHandle);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
      VkDevice                                    device,
      VkExternalMemoryHandleTypeFlagBits          handleType,
      HANDLE                                      handle,
      VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
      VkDevice                                    device,
      const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
      int*                                        pFd);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
      VkDevice                                    device,
      VkExternalMemoryHandleTypeFlagBits          handleType,
      int                                         fd,
      VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
      VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
      VkDevice                                    device,
      const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
      VkDevice                                    device,
      const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
      HANDLE*                                     pHandle);
  
  VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
      VkDevice                                    device,
      const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
      VkDevice                                    device,
      const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
      int*                                        pFd);
  
  VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
      VkCommandBuffer                             commandBuffer,
      VkPipelineBindPoint                         pipelineBindPoint,
      VkPipelineLayout                            layout,
      uint32_t                                    set,
      uint32_t                                    descriptorWriteCount,
      const VkWriteDescriptorSet*                 pDescriptorWrites);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
      VkDevice                                    device,
      const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
  
  VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
      VkDevice                                    device,
      VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(
      VkDevice                                    device,
      const VkRenderPassCreateInfo2*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkRenderPass*                               pRenderPass);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkRenderPassBeginInfo*                pRenderPassBegin,
      const VkSubpassBeginInfo*                   pSubpassBeginInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkSubpassBeginInfo*                   pSubpassBeginInfo,
      const VkSubpassEndInfo*                     pSubpassEndInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkSubpassEndInfo*                     pSubpassEndInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
      VkExternalFenceProperties*                  pExternalFenceProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
      VkDevice                                    device,
      const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
      VkDevice                                    device,
      const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
      HANDLE*                                     pHandle);
  
  VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
      VkDevice                                    device,
      const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
      VkDevice                                    device,
      const VkFenceGetFdInfoKHR*                  pGetFdInfo,
      int*                                        pFd);
  
  VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      uint32_t*                                   pCounterCount,
      VkPerformanceCounterKHR*                    pCounters,
      VkPerformanceCounterDescriptionKHR*         pCounterDescriptions);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
      VkPhysicalDevice                            physicalDevice,
      const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
      uint32_t*                                   pNumPasses);
  
  VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(
      VkDevice                                    device,
      const VkAcquireProfilingLockInfoKHR*        pInfo);
  
  VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(
      VkDevice                                    device);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
      VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
      uint32_t*                                   pSurfaceFormatCount,
      VkSurfaceFormat2KHR*                        pSurfaceFormats);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkDisplayProperties2KHR*                    pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkDisplayPlaneProperties2KHR*               pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display,
      uint32_t*                                   pPropertyCount,
      VkDisplayModeProperties2KHR*                pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
      VkDisplayPlaneCapabilities2KHR*             pCapabilities);
  
  VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
      VkDevice                                    device,
      const VkImageMemoryRequirementsInfo2*       pInfo,
      VkMemoryRequirements2*                      pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
      VkDevice                                    device,
      const VkBufferMemoryRequirementsInfo2*      pInfo,
      VkMemoryRequirements2*                      pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
      VkDevice                                    device,
      const VkImageSparseMemoryRequirementsInfo2* pInfo,
      uint32_t*                                   pSparseMemoryRequirementCount,
      VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(
      VkDevice                                    device,
      const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSamplerYcbcrConversion*                   pYcbcrConversion);
  
  VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(
      VkDevice                                    device,
      VkSamplerYcbcrConversion                    ycbcrConversion,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindBufferMemoryInfo*               pBindInfos);
  
  VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindImageMemoryInfo*                pBindInfos);
  
  VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(
      VkDevice                                    device,
      const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
      VkDescriptorSetLayoutSupport*               pSupport);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      VkBuffer                                    countBuffer,
      VkDeviceSize                                countBufferOffset,
      uint32_t                                    maxDrawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      VkBuffer                                    countBuffer,
      VkDeviceSize                                countBufferOffset,
      uint32_t                                    maxDrawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(
      VkDevice                                    device,
      VkSemaphore                                 semaphore,
      uint64_t*                                   pValue);
  
  VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(
      VkDevice                                    device,
      const VkSemaphoreWaitInfo*                  pWaitInfo,
      uint64_t                                    timeout);
  
  VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(
      VkDevice                                    device,
      const VkSemaphoreSignalInfo*                pSignalInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pFragmentShadingRateCount,
      VkPhysicalDeviceFragmentShadingRateKHR*     pFragmentShadingRates);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(
      VkCommandBuffer                             commandBuffer,
      const VkExtent2D*                           pFragmentSize,
      const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
  
  VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      uint64_t                                    presentId,
      uint64_t                                    timeout);
  
  VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(
      VkDevice                                    device,
      const VkBufferDeviceAddressInfo*            pInfo);
  
  VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(
      VkDevice                                    device,
      const VkBufferDeviceAddressInfo*            pInfo);
  
  VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(
      VkDevice                                    device,
      const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(
      VkDevice                                    device,
      const VkAllocationCallbacks*                pAllocator,
      VkDeferredOperationKHR*                     pDeferredOperation);
  
  VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      operation,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      operation);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      operation);
  
  VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      operation);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(
      VkDevice                                    device,
      const VkPipelineInfoKHR*                    pPipelineInfo,
      uint32_t*                                   pExecutableCount,
      VkPipelineExecutablePropertiesKHR*          pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(
      VkDevice                                    device,
      const VkPipelineExecutableInfoKHR*          pExecutableInfo,
      uint32_t*                                   pStatisticCount,
      VkPipelineExecutableStatisticKHR*           pStatistics);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
      VkDevice                                    device,
      const VkPipelineExecutableInfoKHR*          pExecutableInfo,
      uint32_t*                                   pInternalRepresentationCount,
      VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR(
      VkCommandBuffer                             commandBuffer,
      VkEvent                                     event,
      const VkDependencyInfoKHR*                  pDependencyInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR(
      VkCommandBuffer                             commandBuffer,
      VkEvent                                     event,
      VkPipelineStageFlags2KHR                    stageMask);
  
  VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    eventCount,
      const VkEvent*                              pEvents,
      const VkDependencyInfoKHR*                  pDependencyInfos);
  
  VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkDependencyInfoKHR*                  pDependencyInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR(
      VkCommandBuffer                             commandBuffer,
      VkPipelineStageFlags2KHR                    stage,
      VkQueryPool                                 queryPool,
      uint32_t                                    query);
  
  VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR(
      VkQueue                                     queue,
      uint32_t                                    submitCount,
      const VkSubmitInfo2KHR*                     pSubmits,
      VkFence                                     fence);
  
  VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD(
      VkCommandBuffer                             commandBuffer,
      VkPipelineStageFlags2KHR                    stage,
      VkBuffer                                    dstBuffer,
      VkDeviceSize                                dstOffset,
      uint32_t                                    marker);
  
  VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV(
      VkQueue                                     queue,
      uint32_t*                                   pCheckpointDataCount,
      VkCheckpointData2NV*                        pCheckpointData);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkCopyBufferInfo2KHR*                 pCopyBufferInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkCopyImageInfo2KHR*                  pCopyImageInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkCopyBufferToImageInfo2KHR*          pCopyBufferToImageInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkCopyImageToBufferInfo2KHR*          pCopyImageToBufferInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkBlitImageInfo2KHR*                  pBlitImageInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(
      VkCommandBuffer                             commandBuffer,
      const VkResolveImageInfo2KHR*               pResolveImageInfo);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR(
      VkDevice                                    device,
      const VkDeviceBufferMemoryRequirementsKHR*  pInfo,
      VkMemoryRequirements2*                      pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR(
      VkDevice                                    device,
      const VkDeviceImageMemoryRequirementsKHR*   pInfo,
      VkMemoryRequirements2*                      pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR(
      VkDevice                                    device,
      const VkDeviceImageMemoryRequirementsKHR*   pInfo,
      uint32_t*                                   pSparseMemoryRequirementCount,
      VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
      VkInstance                                  instance,
      const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDebugReportCallbackEXT*                   pCallback);
  
  VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
      VkInstance                                  instance,
      VkDebugReportCallbackEXT                    callback,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
      VkInstance                                  instance,
      VkDebugReportFlagsEXT                       flags,
      VkDebugReportObjectTypeEXT                  objectType,
      uint64_t                                    object,
      size_t                                      location,
      int32_t                                     messageCode,
      const char*                                 pLayerPrefix,
      const char*                                 pMessage);
  
  VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
      VkDevice                                    device,
      const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
      VkDevice                                    device,
      const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
      VkCommandBuffer                             commandBuffer,
      const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
      VkCommandBuffer                             commandBuffer);
  
  VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
      VkCommandBuffer                             commandBuffer,
      const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstBinding,
      uint32_t                                    bindingCount,
      const VkBuffer*                             pBuffers,
      const VkDeviceSize*                         pOffsets,
      const VkDeviceSize*                         pSizes);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstCounterBuffer,
      uint32_t                                    counterBufferCount,
      const VkBuffer*                             pCounterBuffers,
      const VkDeviceSize*                         pCounterBufferOffsets);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstCounterBuffer,
      uint32_t                                    counterBufferCount,
      const VkBuffer*                             pCounterBuffers,
      const VkDeviceSize*                         pCounterBufferOffsets);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(
      VkCommandBuffer                             commandBuffer,
      VkQueryPool                                 queryPool,
      uint32_t                                    query,
      VkQueryControlFlags                         flags,
      uint32_t                                    index);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(
      VkCommandBuffer                             commandBuffer,
      VkQueryPool                                 queryPool,
      uint32_t                                    query,
      uint32_t                                    index);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    instanceCount,
      uint32_t                                    firstInstance,
      VkBuffer                                    counterBuffer,
      VkDeviceSize                                counterBufferOffset,
      uint32_t                                    counterOffset,
      uint32_t                                    vertexStride);
  
  VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(
      VkDevice                                    device,
      const VkImageViewHandleInfoNVX*             pInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(
      VkDevice                                    device,
      VkImageView                                 imageView,
      VkImageViewAddressPropertiesNVX*            pProperties);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      VkBuffer                                    countBuffer,
      VkDeviceSize                                countBufferOffset,
      uint32_t                                    maxDrawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      VkBuffer                                    countBuffer,
      VkDeviceSize                                countBufferOffset,
      uint32_t                                    maxDrawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      VkShaderStageFlagBits                       shaderStage,
      VkShaderInfoTypeAMD                         infoType,
      size_t*                                     pInfoSize,
      void*                                       pInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(
      VkInstance                                  instance,
      const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
      VkPhysicalDevice                            physicalDevice,
      VkFormat                                    format,
      VkImageType                                 type,
      VkImageTiling                               tiling,
      VkImageUsageFlags                           usage,
      VkImageCreateFlags                          flags,
      VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
      VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
      VkDevice                                    device,
      VkDeviceMemory                              memory,
      VkExternalMemoryHandleTypeFlagsNV           handleType,
      HANDLE*                                     pHandle);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
      VkInstance                                  instance,
      const VkViSurfaceCreateInfoNN*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
      VkCommandBuffer                             commandBuffer,
      const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(
      VkCommandBuffer                             commandBuffer);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstViewport,
      uint32_t                                    viewportCount,
      const VkViewportWScalingNV*                 pViewportWScalings);
  
  VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display);
  
  VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      Display*                                    dpy,
      VkDisplayKHR                                display);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      Display*                                    dpy,
      RROutput                                    rrOutput,
      VkDisplayKHR*                               pDisplay);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
  
  VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
      VkDevice                                    device,
      VkDisplayKHR                                display,
      const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
      VkDevice                                    device,
      const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkFence*                                    pFence);
  
  VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
      VkDevice                                    device,
      VkDisplayKHR                                display,
      const VkDisplayEventInfoEXT*                pDisplayEventInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkFence*                                    pFence);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      VkSurfaceCounterFlagBitsEXT                 counter,
      uint64_t*                                   pCounterValue);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      uint32_t*                                   pPresentationTimingCount,
      VkPastPresentationTimingGOOGLE*             pPresentationTimings);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstDiscardRectangle,
      uint32_t                                    discardRectangleCount,
      const VkRect2D*                             pDiscardRectangles);
  
  VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
      VkDevice                                    device,
      uint32_t                                    swapchainCount,
      const VkSwapchainKHR*                       pSwapchains,
      const VkHdrMetadataEXT*                     pMetadata);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
      VkInstance                                  instance,
      const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
      VkInstance                                  instance,
      const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(
      VkDevice                                    device,
      const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(
      VkDevice                                    device,
      const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
  
  VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(
      VkQueue                                     queue,
      const VkDebugUtilsLabelEXT*                 pLabelInfo);
  
  VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(
      VkQueue                                     queue);
  
  VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(
      VkQueue                                     queue,
      const VkDebugUtilsLabelEXT*                 pLabelInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(
      VkCommandBuffer                             commandBuffer,
      const VkDebugUtilsLabelEXT*                 pLabelInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(
      VkCommandBuffer                             commandBuffer);
  
  VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(
      VkCommandBuffer                             commandBuffer,
      const VkDebugUtilsLabelEXT*                 pLabelInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(
      VkInstance                                  instance,
      const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDebugUtilsMessengerEXT*                   pMessenger);
  
  VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(
      VkInstance                                  instance,
      VkDebugUtilsMessengerEXT                    messenger,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(
      VkInstance                                  instance,
      VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
      VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
      const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
      VkDevice                                    device,
      const struct AHardwareBuffer*               buffer,
      VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
      VkDevice                                    device,
      const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
      struct AHardwareBuffer**                    pBuffer);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(
      VkCommandBuffer                             commandBuffer,
      const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
  
  VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(
      VkPhysicalDevice                            physicalDevice,
      VkSampleCountFlagBits                       samples,
      VkMultisamplePropertiesEXT*                 pMultisampleProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(
      VkDevice                                    device,
      VkImage                                     image,
      VkImageDrmFormatModifierPropertiesEXT*      pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(
      VkDevice                                    device,
      const VkValidationCacheCreateInfoEXT*       pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkValidationCacheEXT*                       pValidationCache);
  
  VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(
      VkDevice                                    device,
      VkValidationCacheEXT                        validationCache,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(
      VkDevice                                    device,
      VkValidationCacheEXT                        dstCache,
      uint32_t                                    srcCacheCount,
      const VkValidationCacheEXT*                 pSrcCaches);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
      VkDevice                                    device,
      VkValidationCacheEXT                        validationCache,
      size_t*                                     pDataSize,
      void*                                       pData);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(
      VkCommandBuffer                             commandBuffer,
      VkImageView                                 imageView,
      VkImageLayout                               imageLayout);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstViewport,
      uint32_t                                    viewportCount,
      const VkShadingRatePaletteNV*               pShadingRatePalettes);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(
      VkCommandBuffer                             commandBuffer,
      VkCoarseSampleOrderTypeNV                   sampleOrderType,
      uint32_t                                    customSampleOrderCount,
      const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(
      VkDevice                                    device,
      const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkAccelerationStructureNV*                  pAccelerationStructure);
  
  VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(
      VkDevice                                    device,
      VkAccelerationStructureNV                   accelerationStructure,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
      VkDevice                                    device,
      const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
      VkMemoryRequirements2KHR*                   pMemoryRequirements);
  
  VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
  
  VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(
      VkCommandBuffer                             commandBuffer,
      const VkAccelerationStructureInfoNV*        pInfo,
      VkBuffer                                    instanceData,
      VkDeviceSize                                instanceOffset,
      VkBool32                                    update,
      VkAccelerationStructureNV                   dst,
      VkAccelerationStructureNV                   src,
      VkBuffer                                    scratch,
      VkDeviceSize                                scratchOffset);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(
      VkCommandBuffer                             commandBuffer,
      VkAccelerationStructureNV                   dst,
      VkAccelerationStructureNV                   src,
      VkCopyAccelerationStructureModeKHR          mode);
  
  VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(
      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);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      uint32_t                                    createInfoCount,
      const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkPipeline*                                 pPipelines);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    firstGroup,
      uint32_t                                    groupCount,
      size_t                                      dataSize,
      void*                                       pData);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    firstGroup,
      uint32_t                                    groupCount,
      size_t                                      dataSize,
      void*                                       pData);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(
      VkDevice                                    device,
      VkAccelerationStructureNV                   accelerationStructure,
      size_t                                      dataSize,
      void*                                       pData);
  
  VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    accelerationStructureCount,
      const VkAccelerationStructureNV*            pAccelerationStructures,
      VkQueryType                                 queryType,
      VkQueryPool                                 queryPool,
      uint32_t                                    firstQuery);
  
  VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    shader);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(
      VkDevice                                    device,
      VkExternalMemoryHandleTypeFlagBits          handleType,
      const void*                                 pHostPointer,
      VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
  
  VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
      VkCommandBuffer                             commandBuffer,
      VkPipelineStageFlagBits                     pipelineStage,
      VkBuffer                                    dstBuffer,
      VkDeviceSize                                dstOffset,
      uint32_t                                    marker);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pTimeDomainCount,
      VkTimeDomainEXT*                            pTimeDomains);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(
      VkDevice                                    device,
      uint32_t                                    timestampCount,
      const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
      uint64_t*                                   pTimestamps,
      uint64_t*                                   pMaxDeviation);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    taskCount,
      uint32_t                                    firstTask);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      uint32_t                                    drawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(
      VkCommandBuffer                             commandBuffer,
      VkBuffer                                    buffer,
      VkDeviceSize                                offset,
      VkBuffer                                    countBuffer,
      VkDeviceSize                                countBufferOffset,
      uint32_t                                    maxDrawCount,
      uint32_t                                    stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstExclusiveScissor,
      uint32_t                                    exclusiveScissorCount,
      const VkRect2D*                             pExclusiveScissors);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(
      VkCommandBuffer                             commandBuffer,
      const void*                                 pCheckpointMarker);
  
  VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(
      VkQueue                                     queue,
      uint32_t*                                   pCheckpointDataCount,
      VkCheckpointDataNV*                         pCheckpointData);
  
  VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(
      VkDevice                                    device,
      const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
  
  VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(
      VkDevice                                    device);
  
  VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(
      VkCommandBuffer                             commandBuffer,
      const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(
      VkCommandBuffer                             commandBuffer,
      const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(
      VkCommandBuffer                             commandBuffer,
      const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL(
      VkDevice                                    device,
      const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
      VkPerformanceConfigurationINTEL*            pConfiguration);
  
  VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(
      VkDevice                                    device,
      VkPerformanceConfigurationINTEL             configuration);
  
  VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(
      VkQueue                                     queue,
      VkPerformanceConfigurationINTEL             configuration);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(
      VkDevice                                    device,
      VkPerformanceParameterTypeINTEL             parameter,
      VkPerformanceValueINTEL*                    pValue);
  
  VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(
      VkDevice                                    device,
      VkSwapchainKHR                              swapChain,
      VkBool32                                    localDimmingEnable);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(
      VkInstance                                  instance,
      const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
      VkInstance                                  instance,
      const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
      VkDevice                                    device,
      const VkBufferDeviceAddressInfo*            pInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pToolCount,
      VkPhysicalDeviceToolPropertiesEXT*          pToolProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkCooperativeMatrixPropertiesNV*            pProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pCombinationCount,
      VkFramebufferMixedSamplesCombinationNV*     pCombinations);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
      uint32_t*                                   pPresentModeCount,
      VkPresentModeKHR*                           pPresentModes);
  
  VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain);
  
  VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(
      VkDevice                                    device,
      const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
      VkDeviceGroupPresentModeFlagsKHR*           pModes);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
      VkInstance                                  instance,
      const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    lineStippleFactor,
      uint16_t                                    lineStipplePattern);
  
  VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
      VkDevice                                    device,
      VkQueryPool                                 queryPool,
      uint32_t                                    firstQuery,
      uint32_t                                    queryCount);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(
      VkCommandBuffer                             commandBuffer,
      VkCullModeFlags                             cullMode);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(
      VkCommandBuffer                             commandBuffer,
      VkFrontFace                                 frontFace);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(
      VkCommandBuffer                             commandBuffer,
      VkPrimitiveTopology                         primitiveTopology);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    viewportCount,
      const VkViewport*                           pViewports);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    scissorCount,
      const VkRect2D*                             pScissors);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    firstBinding,
      uint32_t                                    bindingCount,
      const VkBuffer*                             pBuffers,
      const VkDeviceSize*                         pOffsets,
      const VkDeviceSize*                         pSizes,
      const VkDeviceSize*                         pStrides);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(
      VkCommandBuffer                             commandBuffer,
      VkBool32                                    depthTestEnable);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(
      VkCommandBuffer                             commandBuffer,
      VkBool32                                    depthWriteEnable);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(
      VkCommandBuffer                             commandBuffer,
      VkCompareOp                                 depthCompareOp);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(
      VkCommandBuffer                             commandBuffer,
      VkBool32                                    depthBoundsTestEnable);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(
      VkCommandBuffer                             commandBuffer,
      VkBool32                                    stencilTestEnable);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(
      VkCommandBuffer                             commandBuffer,
      VkStencilFaceFlags                          faceMask,
      VkStencilOp                                 failOp,
      VkStencilOp                                 passOp,
      VkStencilOp                                 depthFailOp,
      VkCompareOp                                 compareOp);
  
  VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(
      VkDevice                                    device,
      const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
      VkMemoryRequirements2*                      pMemoryRequirements);
  
  VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(
      VkCommandBuffer                             commandBuffer,
      const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(
      VkCommandBuffer                             commandBuffer,
      VkBool32                                    isPreprocessed,
      const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(
      VkCommandBuffer                             commandBuffer,
      VkPipelineBindPoint                         pipelineBindPoint,
      VkPipeline                                  pipeline,
      uint32_t                                    groupIndex);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(
      VkDevice                                    device,
      const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkIndirectCommandsLayoutNV*                 pIndirectCommandsLayout);
  
  VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(
      VkDevice                                    device,
      VkIndirectCommandsLayoutNV                  indirectCommandsLayout,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      int32_t                                     drmFd,
      VkDisplayKHR                                display);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      int32_t                                     drmFd,
      uint32_t                                    connectorId,
      VkDisplayKHR*                               display);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(
      VkDevice                                    device,
      const VkPrivateDataSlotCreateInfoEXT*       pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkPrivateDataSlotEXT*                       pPrivateDataSlot);
  
  VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(
      VkDevice                                    device,
      VkPrivateDataSlotEXT                        privateDataSlot,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(
      VkDevice                                    device,
      VkObjectType                                objectType,
      uint64_t                                    objectHandle,
      VkPrivateDataSlotEXT                        privateDataSlot,
      uint64_t                                    data);
  
  VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(
      VkDevice                                    device,
      VkObjectType                                objectType,
      uint64_t                                    objectHandle,
      VkPrivateDataSlotEXT                        privateDataSlot,
      uint64_t*                                   pData);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV(
      VkCommandBuffer                             commandBuffer,
      VkFragmentShadingRateNV                     shadingRate,
      const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
  
  VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    deviceRelativeId,
      VkDisplayKHR*                               pDisplay);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(
      VkInstance                                  instance,
      const VkDirectFBSurfaceCreateInfoEXT*       pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      IDirectFB*                                  dfb);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    vertexBindingDescriptionCount,
      const VkVertexInputBindingDescription2EXT*  pVertexBindingDescriptions,
      uint32_t                                    vertexAttributeDescriptionCount,
      const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA(
      VkDevice                                    device,
      const VkMemoryGetZirconHandleInfoFUCHSIA*   pGetZirconHandleInfo,
      zx_handle_t*                                pZirconHandle);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA(
      VkDevice                                    device,
      VkExternalMemoryHandleTypeFlagBits          handleType,
      zx_handle_t                                 zirconHandle,
      VkMemoryZirconHandlePropertiesFUCHSIA*      pMemoryZirconHandleProperties);
  
  VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA(
      VkDevice                                    device,
      const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA(
      VkDevice                                    device,
      const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
      zx_handle_t*                                pZirconHandle);
  
  VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI(
      VkCommandBuffer                             commandBuffer,
      VkImageView                                 imageView,
      VkImageLayout                               imageLayout);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV(
      VkDevice                                    device,
      const VkMemoryGetRemoteAddressInfoNV*       pMemoryGetRemoteAddressInfo,
      VkRemoteAddressNV*                          pAddress);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    patchControlPoints);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT(
      VkCommandBuffer                             commandBuffer,
      VkBool32                                    rasterizerDiscardEnable);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT(
      VkCommandBuffer                             commandBuffer,
      VkBool32                                    depthBiasEnable);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT(
      VkCommandBuffer                             commandBuffer,
      VkLogicOp                                   logicOp);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT(
      VkCommandBuffer                             commandBuffer,
      VkBool32                                    primitiveRestartEnable);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX(
      VkInstance                                  instance,
      const VkScreenSurfaceCreateInfoQNX*         pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface);
  
  VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      struct _screen_window*                      window);
  
  VKAPI_ATTR void                                    VKAPI_CALL CmdSetColorWriteEnableEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    attachmentCount,
      const VkBool32*                             pColorWriteEnables);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    drawCount,
      const VkMultiDrawInfoEXT*                   pVertexInfo,
      uint32_t                                    instanceCount,
      uint32_t                                    firstInstance,
      uint32_t                                    stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    drawCount,
      const VkMultiDrawIndexedInfoEXT*            pIndexInfo,
      uint32_t                                    instanceCount,
      uint32_t                                    firstInstance,
      uint32_t                                    stride,
      const int32_t*                              pVertexOffset);
  
  VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT(
      VkDevice                                    device,
      VkDeviceMemory                              memory,
      float                                       priority);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(
      VkDevice                                    device,
      const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkAccelerationStructureKHR*                 pAccelerationStructure);
  
  VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(
      VkDevice                                    device,
      VkAccelerationStructureKHR                  accelerationStructure,
      const VkAllocationCallbacks*                pAllocator);
  
  VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    infoCount,
      const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
      const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);
  
  VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    infoCount,
      const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
      const VkDeviceAddress*                      pIndirectDeviceAddresses,
      const uint32_t*                             pIndirectStrides,
      const uint32_t* const*                      ppMaxPrimitiveCounts);
  
  VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      deferredOperation,
      const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      deferredOperation,
      const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
  
  VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR(
      VkDevice                                    device,
      uint32_t                                    accelerationStructureCount,
      const VkAccelerationStructureKHR*           pAccelerationStructures,
      VkQueryType                                 queryType,
      size_t                                      dataSize,
      void*                                       pData,
      size_t                                      stride);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(
      VkCommandBuffer                             commandBuffer,
      const VkCopyAccelerationStructureInfoKHR*   pInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(
      VkCommandBuffer                             commandBuffer,
      const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(
      VkCommandBuffer                             commandBuffer,
      const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
  
  VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR(
      VkDevice                                    device,
      const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    accelerationStructureCount,
      const VkAccelerationStructureKHR*           pAccelerationStructures,
      VkQueryType                                 queryType,
      VkQueryPool                                 queryPool,
      uint32_t                                    firstQuery);
  
  VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR(
      VkDevice                                    device,
      const VkAccelerationStructureVersionInfoKHR* pVersionInfo,
      VkAccelerationStructureCompatibilityKHR*    pCompatibility);
  
  VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR(
      VkDevice                                    device,
      VkAccelerationStructureBuildTypeKHR         buildType,
      const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,
      const uint32_t*                             pMaxPrimitiveCounts,
      VkAccelerationStructureBuildSizesInfoKHR*   pSizeInfo);
  
  VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(
      VkCommandBuffer                             commandBuffer,
      const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
      const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
      const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
      const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
      uint32_t                                    width,
      uint32_t                                    height,
      uint32_t                                    depth);
  
  VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      deferredOperation,
      VkPipelineCache                             pipelineCache,
      uint32_t                                    createInfoCount,
      const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkPipeline*                                 pPipelines);
  
  VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    firstGroup,
      uint32_t                                    groupCount,
      size_t                                      dataSize,
      void*                                       pData);
  
  VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(
      VkCommandBuffer                             commandBuffer,
      const VkStridedDeviceAddressRegionKHR*      pRaygenShaderBindingTable,
      const VkStridedDeviceAddressRegionKHR*      pMissShaderBindingTable,
      const VkStridedDeviceAddressRegionKHR*      pHitShaderBindingTable,
      const VkStridedDeviceAddressRegionKHR*      pCallableShaderBindingTable,
      VkDeviceAddress                             indirectDeviceAddress);
  
  VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    group,
      VkShaderGroupShaderKHR                      groupShader);
  
  VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR(
      VkCommandBuffer                             commandBuffer,
      uint32_t                                    pipelineStackSize);
  
  GFXRECON_END_NAMESPACE(encode)
  GFXRECON_END_NAMESPACE(gfxrecon)
  
  #endif
  