text: // *** THIS FILE IS GENERATED - DO NOT EDIT ***
  // See best_practices_generator.py for modifications
  
  
  /***************************************************************************
   *
   * Copyright (c) 2015-2021 The Khronos Group Inc.
   * Copyright (c) 2015-2021 Valve Corporation
   * Copyright (c) 2015-2021 LunarG, Inc.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * Author: Mark Lobodzinski <mark@lunarg.com>
   * Author: Nadav Geva <nadav.geva@amd.com>
   *
   ****************************************************************************/
  
  
  void PostCallRecordCreateInstance(
      const VkInstanceCreateInfo*                 pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkInstance*                                 pInstance,
      VkResult                                    result) override;
  
  
  void PostCallRecordEnumeratePhysicalDevices(
      VkInstance                                  instance,
      uint32_t*                                   pPhysicalDeviceCount,
      VkPhysicalDevice*                           pPhysicalDevices,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceImageFormatProperties(
      VkPhysicalDevice                            physicalDevice,
      VkFormat                                    format,
      VkImageType                                 type,
      VkImageTiling                               tiling,
      VkImageUsageFlags                           usage,
      VkImageCreateFlags                          flags,
      VkImageFormatProperties*                    pImageFormatProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDevice(
      VkPhysicalDevice                            physicalDevice,
      const VkDeviceCreateInfo*                   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDevice*                                   pDevice,
      VkResult                                    result) override;
  
  
  void PostCallRecordEnumerateInstanceExtensionProperties(
      const char*                                 pLayerName,
      uint32_t*                                   pPropertyCount,
      VkExtensionProperties*                      pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordEnumerateDeviceExtensionProperties(
      VkPhysicalDevice                            physicalDevice,
      const char*                                 pLayerName,
      uint32_t*                                   pPropertyCount,
      VkExtensionProperties*                      pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordEnumerateInstanceLayerProperties(
      uint32_t*                                   pPropertyCount,
      VkLayerProperties*                          pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordEnumerateDeviceLayerProperties(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkLayerProperties*                          pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordQueueSubmit(
      VkQueue                                     queue,
      uint32_t                                    submitCount,
      const VkSubmitInfo*                         pSubmits,
      VkFence                                     fence,
      VkResult                                    result) override;
  
  
  void PostCallRecordQueueWaitIdle(
      VkQueue                                     queue,
      VkResult                                    result) override;
  
  
  void PostCallRecordDeviceWaitIdle(
      VkDevice                                    device,
      VkResult                                    result) override;
  
  
  void PostCallRecordAllocateMemory(
      VkDevice                                    device,
      const VkMemoryAllocateInfo*                 pAllocateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDeviceMemory*                             pMemory,
      VkResult                                    result) override;
  
  
  void PostCallRecordMapMemory(
      VkDevice                                    device,
      VkDeviceMemory                              memory,
      VkDeviceSize                                offset,
      VkDeviceSize                                size,
      VkMemoryMapFlags                            flags,
      void**                                      ppData,
      VkResult                                    result) override;
  
  
  void PostCallRecordFlushMappedMemoryRanges(
      VkDevice                                    device,
      uint32_t                                    memoryRangeCount,
      const VkMappedMemoryRange*                  pMemoryRanges,
      VkResult                                    result) override;
  
  
  void PostCallRecordInvalidateMappedMemoryRanges(
      VkDevice                                    device,
      uint32_t                                    memoryRangeCount,
      const VkMappedMemoryRange*                  pMemoryRanges,
      VkResult                                    result) override;
  
  
  void PostCallRecordBindBufferMemory(
      VkDevice                                    device,
      VkBuffer                                    buffer,
      VkDeviceMemory                              memory,
      VkDeviceSize                                memoryOffset,
      VkResult                                    result) override;
  
  
  void PostCallRecordBindImageMemory(
      VkDevice                                    device,
      VkImage                                     image,
      VkDeviceMemory                              memory,
      VkDeviceSize                                memoryOffset,
      VkResult                                    result) override;
  
  
  void PostCallRecordQueueBindSparse(
      VkQueue                                     queue,
      uint32_t                                    bindInfoCount,
      const VkBindSparseInfo*                     pBindInfo,
      VkFence                                     fence,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateFence(
      VkDevice                                    device,
      const VkFenceCreateInfo*                    pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkFence*                                    pFence,
      VkResult                                    result) override;
  
  
  void PostCallRecordResetFences(
      VkDevice                                    device,
      uint32_t                                    fenceCount,
      const VkFence*                              pFences,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetFenceStatus(
      VkDevice                                    device,
      VkFence                                     fence,
      VkResult                                    result) override;
  
  
  void PostCallRecordWaitForFences(
      VkDevice                                    device,
      uint32_t                                    fenceCount,
      const VkFence*                              pFences,
      VkBool32                                    waitAll,
      uint64_t                                    timeout,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateSemaphore(
      VkDevice                                    device,
      const VkSemaphoreCreateInfo*                pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSemaphore*                                pSemaphore,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateEvent(
      VkDevice                                    device,
      const VkEventCreateInfo*                    pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkEvent*                                    pEvent,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetEventStatus(
      VkDevice                                    device,
      VkEvent                                     event,
      VkResult                                    result) override;
  
  
  void PostCallRecordSetEvent(
      VkDevice                                    device,
      VkEvent                                     event,
      VkResult                                    result) override;
  
  
  void PostCallRecordResetEvent(
      VkDevice                                    device,
      VkEvent                                     event,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateQueryPool(
      VkDevice                                    device,
      const VkQueryPoolCreateInfo*                pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkQueryPool*                                pQueryPool,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetQueryPoolResults(
      VkDevice                                    device,
      VkQueryPool                                 queryPool,
      uint32_t                                    firstQuery,
      uint32_t                                    queryCount,
      size_t                                      dataSize,
      void*                                       pData,
      VkDeviceSize                                stride,
      VkQueryResultFlags                          flags,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateBuffer(
      VkDevice                                    device,
      const VkBufferCreateInfo*                   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkBuffer*                                   pBuffer,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateBufferView(
      VkDevice                                    device,
      const VkBufferViewCreateInfo*               pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkBufferView*                               pView,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateImage(
      VkDevice                                    device,
      const VkImageCreateInfo*                    pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkImage*                                    pImage,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateImageView(
      VkDevice                                    device,
      const VkImageViewCreateInfo*                pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkImageView*                                pView,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateShaderModule(
      VkDevice                                    device,
      const VkShaderModuleCreateInfo*             pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkShaderModule*                             pShaderModule,
      VkResult                                    result,
      void*                                       state_data) override;
  
  
  void PostCallRecordCreatePipelineCache(
      VkDevice                                    device,
      const VkPipelineCacheCreateInfo*            pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkPipelineCache*                            pPipelineCache,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPipelineCacheData(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      size_t*                                     pDataSize,
      void*                                       pData,
      VkResult                                    result) override;
  
  
  void PostCallRecordMergePipelineCaches(
      VkDevice                                    device,
      VkPipelineCache                             dstCache,
      uint32_t                                    srcCacheCount,
      const VkPipelineCache*                      pSrcCaches,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateGraphicsPipelines(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      uint32_t                                    createInfoCount,
      const VkGraphicsPipelineCreateInfo*         pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkPipeline*                                 pPipelines,
      VkResult                                    result,
      void*                                       state_data) override;
  
  
  void PostCallRecordCreateComputePipelines(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      uint32_t                                    createInfoCount,
      const VkComputePipelineCreateInfo*          pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkPipeline*                                 pPipelines,
      VkResult                                    result,
      void*                                       state_data) override;
  
  
  void PostCallRecordCreatePipelineLayout(
      VkDevice                                    device,
      const VkPipelineLayoutCreateInfo*           pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkPipelineLayout*                           pPipelineLayout,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateSampler(
      VkDevice                                    device,
      const VkSamplerCreateInfo*                  pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSampler*                                  pSampler,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDescriptorSetLayout(
      VkDevice                                    device,
      const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDescriptorSetLayout*                      pSetLayout,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDescriptorPool(
      VkDevice                                    device,
      const VkDescriptorPoolCreateInfo*           pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDescriptorPool*                           pDescriptorPool,
      VkResult                                    result) override;
  
  
  void PostCallRecordAllocateDescriptorSets(
      VkDevice                                    device,
      const VkDescriptorSetAllocateInfo*          pAllocateInfo,
      VkDescriptorSet*                            pDescriptorSets,
      VkResult                                    result,
      void*                                       state_data) override;
  
  
  void PostCallRecordCreateFramebuffer(
      VkDevice                                    device,
      const VkFramebufferCreateInfo*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkFramebuffer*                              pFramebuffer,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateRenderPass(
      VkDevice                                    device,
      const VkRenderPassCreateInfo*               pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkRenderPass*                               pRenderPass,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateCommandPool(
      VkDevice                                    device,
      const VkCommandPoolCreateInfo*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkCommandPool*                              pCommandPool,
      VkResult                                    result) override;
  
  
  void PostCallRecordResetCommandPool(
      VkDevice                                    device,
      VkCommandPool                               commandPool,
      VkCommandPoolResetFlags                     flags,
      VkResult                                    result) override;
  
  
  void PostCallRecordAllocateCommandBuffers(
      VkDevice                                    device,
      const VkCommandBufferAllocateInfo*          pAllocateInfo,
      VkCommandBuffer*                            pCommandBuffers,
      VkResult                                    result) override;
  
  
  void PostCallRecordBeginCommandBuffer(
      VkCommandBuffer                             commandBuffer,
      const VkCommandBufferBeginInfo*             pBeginInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordEndCommandBuffer(
      VkCommandBuffer                             commandBuffer,
      VkResult                                    result) override;
  
  
  void PostCallRecordResetCommandBuffer(
      VkCommandBuffer                             commandBuffer,
      VkCommandBufferResetFlags                   flags,
      VkResult                                    result) override;
  
  
  void PostCallRecordBindBufferMemory2(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindBufferMemoryInfo*               pBindInfos,
      VkResult                                    result) override;
  
  
  void PostCallRecordBindImageMemory2(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindImageMemoryInfo*                pBindInfos,
      VkResult                                    result) override;
  
  
  void PostCallRecordEnumeratePhysicalDeviceGroups(
      VkInstance                                  instance,
      uint32_t*                                   pPhysicalDeviceGroupCount,
      VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceImageFormatProperties2(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
      VkImageFormatProperties2*                   pImageFormatProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateSamplerYcbcrConversion(
      VkDevice                                    device,
      const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSamplerYcbcrConversion*                   pYcbcrConversion,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDescriptorUpdateTemplate(
      VkDevice                                    device,
      const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateRenderPass2(
      VkDevice                                    device,
      const VkRenderPassCreateInfo2*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkRenderPass*                               pRenderPass,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetSemaphoreCounterValue(
      VkDevice                                    device,
      VkSemaphore                                 semaphore,
      uint64_t*                                   pValue,
      VkResult                                    result) override;
  
  
  void PostCallRecordWaitSemaphores(
      VkDevice                                    device,
      const VkSemaphoreWaitInfo*                  pWaitInfo,
      uint64_t                                    timeout,
      VkResult                                    result) override;
  
  
  void PostCallRecordSignalSemaphore(
      VkDevice                                    device,
      const VkSemaphoreSignalInfo*                pSignalInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      VkSurfaceKHR                                surface,
      VkBool32*                                   pSupported,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      uint32_t*                                   pSurfaceFormatCount,
      VkSurfaceFormatKHR*                         pSurfaceFormats,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      uint32_t*                                   pPresentModeCount,
      VkPresentModeKHR*                           pPresentModes,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateSwapchainKHR(
      VkDevice                                    device,
      const VkSwapchainCreateInfoKHR*             pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSwapchainKHR*                             pSwapchain,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetSwapchainImagesKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      uint32_t*                                   pSwapchainImageCount,
      VkImage*                                    pSwapchainImages,
      VkResult                                    result) override;
  
  
  void PostCallRecordAcquireNextImageKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      uint64_t                                    timeout,
      VkSemaphore                                 semaphore,
      VkFence                                     fence,
      uint32_t*                                   pImageIndex,
      VkResult                                    result) override;
  
  
  void PostCallRecordQueuePresentKHR(
      VkQueue                                     queue,
      const VkPresentInfoKHR*                     pPresentInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDeviceGroupPresentCapabilitiesKHR(
      VkDevice                                    device,
      VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDeviceGroupSurfacePresentModesKHR(
      VkDevice                                    device,
      VkSurfaceKHR                                surface,
      VkDeviceGroupPresentModeFlagsKHR*           pModes,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDevicePresentRectanglesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      uint32_t*                                   pRectCount,
      VkRect2D*                                   pRects,
      VkResult                                    result) override;
  
  
  void PostCallRecordAcquireNextImage2KHR(
      VkDevice                                    device,
      const VkAcquireNextImageInfoKHR*            pAcquireInfo,
      uint32_t*                                   pImageIndex,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceDisplayPropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkDisplayPropertiesKHR*                     pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkDisplayPlanePropertiesKHR*                pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDisplayPlaneSupportedDisplaysKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    planeIndex,
      uint32_t*                                   pDisplayCount,
      VkDisplayKHR*                               pDisplays,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDisplayModePropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display,
      uint32_t*                                   pPropertyCount,
      VkDisplayModePropertiesKHR*                 pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDisplayModeKHR(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display,
      const VkDisplayModeCreateInfoKHR*           pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDisplayModeKHR*                           pMode,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDisplayPlaneCapabilitiesKHR(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayModeKHR                            mode,
      uint32_t                                    planeIndex,
      VkDisplayPlaneCapabilitiesKHR*              pCapabilities,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDisplayPlaneSurfaceKHR(
      VkInstance                                  instance,
      const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateSharedSwapchainsKHR(
      VkDevice                                    device,
      uint32_t                                    swapchainCount,
      const VkSwapchainCreateInfoKHR*             pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkSwapchainKHR*                             pSwapchains,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_XLIB_KHR
  
  void PostCallRecordCreateXlibSurfaceKHR(
      VkInstance                                  instance,
      const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_XLIB_KHR
  
  #ifdef VK_USE_PLATFORM_XCB_KHR
  
  void PostCallRecordCreateXcbSurfaceKHR(
      VkInstance                                  instance,
      const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_XCB_KHR
  
  #ifdef VK_USE_PLATFORM_WAYLAND_KHR
  
  void PostCallRecordCreateWaylandSurfaceKHR(
      VkInstance                                  instance,
      const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WAYLAND_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  
  void PostCallRecordCreateAndroidSurfaceKHR(
      VkInstance                                  instance,
      const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordCreateWin32SurfaceKHR(
      VkInstance                                  instance,
      const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_ENABLE_BETA_EXTENSIONS
  
  void PostCallRecordGetPhysicalDeviceVideoCapabilitiesKHR(
      VkPhysicalDevice                            physicalDevice,
      const VkVideoProfileKHR*                    pVideoProfile,
      VkVideoCapabilitiesKHR*                     pCapabilities,
      VkResult                                    result) override;
  
  
  #endif // VK_ENABLE_BETA_EXTENSIONS
  
  #ifdef VK_ENABLE_BETA_EXTENSIONS
  
  void PostCallRecordGetPhysicalDeviceVideoFormatPropertiesKHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceVideoFormatInfoKHR*   pVideoFormatInfo,
      uint32_t*                                   pVideoFormatPropertyCount,
      VkVideoFormatPropertiesKHR*                 pVideoFormatProperties,
      VkResult                                    result) override;
  
  
  #endif // VK_ENABLE_BETA_EXTENSIONS
  
  #ifdef VK_ENABLE_BETA_EXTENSIONS
  
  void PostCallRecordCreateVideoSessionKHR(
      VkDevice                                    device,
      const VkVideoSessionCreateInfoKHR*          pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkVideoSessionKHR*                          pVideoSession,
      VkResult                                    result) override;
  
  
  #endif // VK_ENABLE_BETA_EXTENSIONS
  
  #ifdef VK_ENABLE_BETA_EXTENSIONS
  
  void PostCallRecordGetVideoSessionMemoryRequirementsKHR(
      VkDevice                                    device,
      VkVideoSessionKHR                           videoSession,
      uint32_t*                                   pVideoSessionMemoryRequirementsCount,
      VkVideoGetMemoryPropertiesKHR*              pVideoSessionMemoryRequirements,
      VkResult                                    result) override;
  
  
  #endif // VK_ENABLE_BETA_EXTENSIONS
  
  #ifdef VK_ENABLE_BETA_EXTENSIONS
  
  void PostCallRecordBindVideoSessionMemoryKHR(
      VkDevice                                    device,
      VkVideoSessionKHR                           videoSession,
      uint32_t                                    videoSessionBindMemoryCount,
      const VkVideoBindMemoryKHR*                 pVideoSessionBindMemories,
      VkResult                                    result) override;
  
  
  #endif // VK_ENABLE_BETA_EXTENSIONS
  
  #ifdef VK_ENABLE_BETA_EXTENSIONS
  
  void PostCallRecordCreateVideoSessionParametersKHR(
      VkDevice                                    device,
      const VkVideoSessionParametersCreateInfoKHR* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkVideoSessionParametersKHR*                pVideoSessionParameters,
      VkResult                                    result) override;
  
  
  #endif // VK_ENABLE_BETA_EXTENSIONS
  
  #ifdef VK_ENABLE_BETA_EXTENSIONS
  
  void PostCallRecordUpdateVideoSessionParametersKHR(
      VkDevice                                    device,
      VkVideoSessionParametersKHR                 videoSessionParameters,
      const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo,
      VkResult                                    result) override;
  
  
  #endif // VK_ENABLE_BETA_EXTENSIONS
  
  void PostCallRecordGetPhysicalDeviceImageFormatProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
      VkImageFormatProperties2*                   pImageFormatProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordEnumeratePhysicalDeviceGroupsKHR(
      VkInstance                                  instance,
      uint32_t*                                   pPhysicalDeviceGroupCount,
      VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetMemoryWin32HandleKHR(
      VkDevice                                    device,
      const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
      HANDLE*                                     pHandle,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetMemoryWin32HandlePropertiesKHR(
      VkDevice                                    device,
      VkExternalMemoryHandleTypeFlagBits          handleType,
      HANDLE                                      handle,
      VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetMemoryFdKHR(
      VkDevice                                    device,
      const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
      int*                                        pFd,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetMemoryFdPropertiesKHR(
      VkDevice                                    device,
      VkExternalMemoryHandleTypeFlagBits          handleType,
      int                                         fd,
      VkMemoryFdPropertiesKHR*                    pMemoryFdProperties,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordImportSemaphoreWin32HandleKHR(
      VkDevice                                    device,
      const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetSemaphoreWin32HandleKHR(
      VkDevice                                    device,
      const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
      HANDLE*                                     pHandle,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordImportSemaphoreFdKHR(
      VkDevice                                    device,
      const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetSemaphoreFdKHR(
      VkDevice                                    device,
      const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
      int*                                        pFd,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDescriptorUpdateTemplateKHR(
      VkDevice                                    device,
      const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateRenderPass2KHR(
      VkDevice                                    device,
      const VkRenderPassCreateInfo2*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkRenderPass*                               pRenderPass,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetSwapchainStatusKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordImportFenceWin32HandleKHR(
      VkDevice                                    device,
      const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetFenceWin32HandleKHR(
      VkDevice                                    device,
      const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
      HANDLE*                                     pHandle,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordImportFenceFdKHR(
      VkDevice                                    device,
      const VkImportFenceFdInfoKHR*               pImportFenceFdInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetFenceFdKHR(
      VkDevice                                    device,
      const VkFenceGetFdInfoKHR*                  pGetFdInfo,
      int*                                        pFd,
      VkResult                                    result) override;
  
  
  void PostCallRecordEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    queueFamilyIndex,
      uint32_t*                                   pCounterCount,
      VkPerformanceCounterKHR*                    pCounters,
      VkPerformanceCounterDescriptionKHR*         pCounterDescriptions,
      VkResult                                    result) override;
  
  
  void PostCallRecordAcquireProfilingLockKHR(
      VkDevice                                    device,
      const VkAcquireProfilingLockInfoKHR*        pInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
      VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
      uint32_t*                                   pSurfaceFormatCount,
      VkSurfaceFormat2KHR*                        pSurfaceFormats,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceDisplayProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkDisplayProperties2KHR*                    pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkDisplayPlaneProperties2KHR*               pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDisplayModeProperties2KHR(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display,
      uint32_t*                                   pPropertyCount,
      VkDisplayModeProperties2KHR*                pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDisplayPlaneCapabilities2KHR(
      VkPhysicalDevice                            physicalDevice,
      const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
      VkDisplayPlaneCapabilities2KHR*             pCapabilities,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateSamplerYcbcrConversionKHR(
      VkDevice                                    device,
      const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSamplerYcbcrConversion*                   pYcbcrConversion,
      VkResult                                    result) override;
  
  
  void PostCallRecordBindBufferMemory2KHR(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindBufferMemoryInfo*               pBindInfos,
      VkResult                                    result) override;
  
  
  void PostCallRecordBindImageMemory2KHR(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindImageMemoryInfo*                pBindInfos,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetSemaphoreCounterValueKHR(
      VkDevice                                    device,
      VkSemaphore                                 semaphore,
      uint64_t*                                   pValue,
      VkResult                                    result) override;
  
  
  void PostCallRecordWaitSemaphoresKHR(
      VkDevice                                    device,
      const VkSemaphoreWaitInfo*                  pWaitInfo,
      uint64_t                                    timeout,
      VkResult                                    result) override;
  
  
  void PostCallRecordSignalSemaphoreKHR(
      VkDevice                                    device,
      const VkSemaphoreSignalInfo*                pSignalInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceFragmentShadingRatesKHR(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pFragmentShadingRateCount,
      VkPhysicalDeviceFragmentShadingRateKHR*     pFragmentShadingRates,
      VkResult                                    result) override;
  
  
  void PostCallRecordWaitForPresentKHR(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      uint64_t                                    presentId,
      uint64_t                                    timeout,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDeferredOperationKHR(
      VkDevice                                    device,
      const VkAllocationCallbacks*                pAllocator,
      VkDeferredOperationKHR*                     pDeferredOperation,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDeferredOperationResultKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      operation,
      VkResult                                    result) override;
  
  
  void PostCallRecordDeferredOperationJoinKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      operation,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPipelineExecutablePropertiesKHR(
      VkDevice                                    device,
      const VkPipelineInfoKHR*                    pPipelineInfo,
      uint32_t*                                   pExecutableCount,
      VkPipelineExecutablePropertiesKHR*          pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPipelineExecutableStatisticsKHR(
      VkDevice                                    device,
      const VkPipelineExecutableInfoKHR*          pExecutableInfo,
      uint32_t*                                   pStatisticCount,
      VkPipelineExecutableStatisticKHR*           pStatistics,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPipelineExecutableInternalRepresentationsKHR(
      VkDevice                                    device,
      const VkPipelineExecutableInfoKHR*          pExecutableInfo,
      uint32_t*                                   pInternalRepresentationCount,
      VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations,
      VkResult                                    result) override;
  
  
  void PostCallRecordQueueSubmit2KHR(
      VkQueue                                     queue,
      uint32_t                                    submitCount,
      const VkSubmitInfo2KHR*                     pSubmits,
      VkFence                                     fence,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDebugReportCallbackEXT(
      VkInstance                                  instance,
      const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDebugReportCallbackEXT*                   pCallback,
      VkResult                                    result) override;
  
  
  void PostCallRecordDebugMarkerSetObjectTagEXT(
      VkDevice                                    device,
      const VkDebugMarkerObjectTagInfoEXT*        pTagInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordDebugMarkerSetObjectNameEXT(
      VkDevice                                    device,
      const VkDebugMarkerObjectNameInfoEXT*       pNameInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateCuModuleNVX(
      VkDevice                                    device,
      const VkCuModuleCreateInfoNVX*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkCuModuleNVX*                              pModule,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateCuFunctionNVX(
      VkDevice                                    device,
      const VkCuFunctionCreateInfoNVX*            pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkCuFunctionNVX*                            pFunction,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetImageViewAddressNVX(
      VkDevice                                    device,
      VkImageView                                 imageView,
      VkImageViewAddressPropertiesNVX*            pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetShaderInfoAMD(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      VkShaderStageFlagBits                       shaderStage,
      VkShaderInfoTypeAMD                         infoType,
      size_t*                                     pInfoSize,
      void*                                       pInfo,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_GGP
  
  void PostCallRecordCreateStreamDescriptorSurfaceGGP(
      VkInstance                                  instance,
      const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_GGP
  
  void PostCallRecordGetPhysicalDeviceExternalImageFormatPropertiesNV(
      VkPhysicalDevice                            physicalDevice,
      VkFormat                                    format,
      VkImageType                                 type,
      VkImageTiling                               tiling,
      VkImageUsageFlags                           usage,
      VkImageCreateFlags                          flags,
      VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
      VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetMemoryWin32HandleNV(
      VkDevice                                    device,
      VkDeviceMemory                              memory,
      VkExternalMemoryHandleTypeFlagsNV           handleType,
      HANDLE*                                     pHandle,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_VI_NN
  
  void PostCallRecordCreateViSurfaceNN(
      VkInstance                                  instance,
      const VkViSurfaceCreateInfoNN*              pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_VI_NN
  
  #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
  
  void PostCallRecordAcquireXlibDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      Display*                                    dpy,
      VkDisplayKHR                                display,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
  
  #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
  
  void PostCallRecordGetRandROutputDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      Display*                                    dpy,
      RROutput                                    rrOutput,
      VkDisplayKHR*                               pDisplay,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT
  
  void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(
      VkPhysicalDevice                            physicalDevice,
      VkSurfaceKHR                                surface,
      VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities,
      VkResult                                    result) override;
  
  
  void PostCallRecordDisplayPowerControlEXT(
      VkDevice                                    device,
      VkDisplayKHR                                display,
      const VkDisplayPowerInfoEXT*                pDisplayPowerInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordRegisterDeviceEventEXT(
      VkDevice                                    device,
      const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkFence*                                    pFence,
      VkResult                                    result) override;
  
  
  void PostCallRecordRegisterDisplayEventEXT(
      VkDevice                                    device,
      VkDisplayKHR                                display,
      const VkDisplayEventInfoEXT*                pDisplayEventInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkFence*                                    pFence,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetSwapchainCounterEXT(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      VkSurfaceCounterFlagBitsEXT                 counter,
      uint64_t*                                   pCounterValue,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetRefreshCycleDurationGOOGLE(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPastPresentationTimingGOOGLE(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      uint32_t*                                   pPresentationTimingCount,
      VkPastPresentationTimingGOOGLE*             pPresentationTimings,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_IOS_MVK
  
  void PostCallRecordCreateIOSSurfaceMVK(
      VkInstance                                  instance,
      const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_IOS_MVK
  
  #ifdef VK_USE_PLATFORM_MACOS_MVK
  
  void PostCallRecordCreateMacOSSurfaceMVK(
      VkInstance                                  instance,
      const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_MACOS_MVK
  
  void PostCallRecordSetDebugUtilsObjectNameEXT(
      VkDevice                                    device,
      const VkDebugUtilsObjectNameInfoEXT*        pNameInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordSetDebugUtilsObjectTagEXT(
      VkDevice                                    device,
      const VkDebugUtilsObjectTagInfoEXT*         pTagInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateDebugUtilsMessengerEXT(
      VkInstance                                  instance,
      const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkDebugUtilsMessengerEXT*                   pMessenger,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  
  void PostCallRecordGetAndroidHardwareBufferPropertiesANDROID(
      VkDevice                                    device,
      const struct AHardwareBuffer*               buffer,
      VkAndroidHardwareBufferPropertiesANDROID*   pProperties,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  #ifdef VK_USE_PLATFORM_ANDROID_KHR
  
  void PostCallRecordGetMemoryAndroidHardwareBufferANDROID(
      VkDevice                                    device,
      const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
      struct AHardwareBuffer**                    pBuffer,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_ANDROID_KHR
  
  void PostCallRecordGetImageDrmFormatModifierPropertiesEXT(
      VkDevice                                    device,
      VkImage                                     image,
      VkImageDrmFormatModifierPropertiesEXT*      pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateAccelerationStructureNV(
      VkDevice                                    device,
      const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkAccelerationStructureNV*                  pAccelerationStructure,
      VkResult                                    result) override;
  
  
  void PostCallRecordBindAccelerationStructureMemoryNV(
      VkDevice                                    device,
      uint32_t                                    bindInfoCount,
      const VkBindAccelerationStructureMemoryInfoNV* pBindInfos,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateRayTracingPipelinesNV(
      VkDevice                                    device,
      VkPipelineCache                             pipelineCache,
      uint32_t                                    createInfoCount,
      const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkPipeline*                                 pPipelines,
      VkResult                                    result,
      void*                                       state_data) override;
  
  
  void PostCallRecordGetRayTracingShaderGroupHandlesKHR(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    firstGroup,
      uint32_t                                    groupCount,
      size_t                                      dataSize,
      void*                                       pData,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetRayTracingShaderGroupHandlesNV(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    firstGroup,
      uint32_t                                    groupCount,
      size_t                                      dataSize,
      void*                                       pData,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetAccelerationStructureHandleNV(
      VkDevice                                    device,
      VkAccelerationStructureNV                   accelerationStructure,
      size_t                                      dataSize,
      void*                                       pData,
      VkResult                                    result) override;
  
  
  void PostCallRecordCompileDeferredNV(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    shader,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetMemoryHostPointerPropertiesEXT(
      VkDevice                                    device,
      VkExternalMemoryHandleTypeFlagBits          handleType,
      const void*                                 pHostPointer,
      VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceCalibrateableTimeDomainsEXT(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pTimeDomainCount,
      VkTimeDomainEXT*                            pTimeDomains,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetCalibratedTimestampsEXT(
      VkDevice                                    device,
      uint32_t                                    timestampCount,
      const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
      uint64_t*                                   pTimestamps,
      uint64_t*                                   pMaxDeviation,
      VkResult                                    result) override;
  
  
  void PostCallRecordInitializePerformanceApiINTEL(
      VkDevice                                    device,
      const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordCmdSetPerformanceMarkerINTEL(
      VkCommandBuffer                             commandBuffer,
      const VkPerformanceMarkerInfoINTEL*         pMarkerInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordCmdSetPerformanceStreamMarkerINTEL(
      VkCommandBuffer                             commandBuffer,
      const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordCmdSetPerformanceOverrideINTEL(
      VkCommandBuffer                             commandBuffer,
      const VkPerformanceOverrideInfoINTEL*       pOverrideInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordAcquirePerformanceConfigurationINTEL(
      VkDevice                                    device,
      const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
      VkPerformanceConfigurationINTEL*            pConfiguration,
      VkResult                                    result) override;
  
  
  void PostCallRecordReleasePerformanceConfigurationINTEL(
      VkDevice                                    device,
      VkPerformanceConfigurationINTEL             configuration,
      VkResult                                    result) override;
  
  
  void PostCallRecordQueueSetPerformanceConfigurationINTEL(
      VkQueue                                     queue,
      VkPerformanceConfigurationINTEL             configuration,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPerformanceParameterINTEL(
      VkDevice                                    device,
      VkPerformanceParameterTypeINTEL             parameter,
      VkPerformanceValueINTEL*                    pValue,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordCreateImagePipeSurfaceFUCHSIA(
      VkInstance                                  instance,
      const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  #ifdef VK_USE_PLATFORM_METAL_EXT
  
  void PostCallRecordCreateMetalSurfaceEXT(
      VkInstance                                  instance,
      const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_METAL_EXT
  
  void PostCallRecordGetPhysicalDeviceToolPropertiesEXT(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pToolCount,
      VkPhysicalDeviceToolPropertiesEXT*          pToolProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceCooperativeMatrixPropertiesNV(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pPropertyCount,
      VkCooperativeMatrixPropertiesNV*            pProperties,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
      VkPhysicalDevice                            physicalDevice,
      uint32_t*                                   pCombinationCount,
      VkFramebufferMixedSamplesCombinationNV*     pCombinations,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetPhysicalDeviceSurfacePresentModes2EXT(
      VkPhysicalDevice                            physicalDevice,
      const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
      uint32_t*                                   pPresentModeCount,
      VkPresentModeKHR*                           pPresentModes,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordAcquireFullScreenExclusiveModeEXT(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordReleaseFullScreenExclusiveModeEXT(
      VkDevice                                    device,
      VkSwapchainKHR                              swapchain,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetDeviceGroupSurfacePresentModes2EXT(
      VkDevice                                    device,
      const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
      VkDeviceGroupPresentModeFlagsKHR*           pModes,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordCreateHeadlessSurfaceEXT(
      VkInstance                                  instance,
      const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateIndirectCommandsLayoutNV(
      VkDevice                                    device,
      const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkIndirectCommandsLayoutNV*                 pIndirectCommandsLayout,
      VkResult                                    result) override;
  
  
  void PostCallRecordAcquireDrmDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      int32_t                                     drmFd,
      VkDisplayKHR                                display,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetDrmDisplayEXT(
      VkPhysicalDevice                            physicalDevice,
      int32_t                                     drmFd,
      uint32_t                                    connectorId,
      VkDisplayKHR*                               display,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreatePrivateDataSlotEXT(
      VkDevice                                    device,
      const VkPrivateDataSlotCreateInfoEXT*       pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkPrivateDataSlotEXT*                       pPrivateDataSlot,
      VkResult                                    result) override;
  
  
  void PostCallRecordSetPrivateDataEXT(
      VkDevice                                    device,
      VkObjectType                                objectType,
      uint64_t                                    objectHandle,
      VkPrivateDataSlotEXT                        privateDataSlot,
      uint64_t                                    data,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordAcquireWinrtDisplayNV(
      VkPhysicalDevice                            physicalDevice,
      VkDisplayKHR                                display,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_WIN32_KHR
  
  void PostCallRecordGetWinrtDisplayNV(
      VkPhysicalDevice                            physicalDevice,
      uint32_t                                    deviceRelativeId,
      VkDisplayKHR*                               pDisplay,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_WIN32_KHR
  
  #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
  
  void PostCallRecordCreateDirectFBSurfaceEXT(
      VkInstance                                  instance,
      const VkDirectFBSurfaceCreateInfoEXT*       pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_DIRECTFB_EXT
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordGetMemoryZirconHandleFUCHSIA(
      VkDevice                                    device,
      const VkMemoryGetZirconHandleInfoFUCHSIA*   pGetZirconHandleInfo,
      zx_handle_t*                                pZirconHandle,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordGetMemoryZirconHandlePropertiesFUCHSIA(
      VkDevice                                    device,
      VkExternalMemoryHandleTypeFlagBits          handleType,
      zx_handle_t                                 zirconHandle,
      VkMemoryZirconHandlePropertiesFUCHSIA*      pMemoryZirconHandleProperties,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordImportSemaphoreZirconHandleFUCHSIA(
      VkDevice                                    device,
      const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordGetSemaphoreZirconHandleFUCHSIA(
      VkDevice                                    device,
      const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo,
      zx_handle_t*                                pZirconHandle,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordCreateBufferCollectionFUCHSIA(
      VkDevice                                    device,
      const VkBufferCollectionCreateInfoFUCHSIA*  pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkBufferCollectionFUCHSIA*                  pCollection,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordSetBufferCollectionImageConstraintsFUCHSIA(
      VkDevice                                    device,
      VkBufferCollectionFUCHSIA                   collection,
      const VkImageConstraintsInfoFUCHSIA*        pImageConstraintsInfo,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordSetBufferCollectionBufferConstraintsFUCHSIA(
      VkDevice                                    device,
      VkBufferCollectionFUCHSIA                   collection,
      const VkBufferConstraintsInfoFUCHSIA*       pBufferConstraintsInfo,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  #ifdef VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordGetBufferCollectionPropertiesFUCHSIA(
      VkDevice                                    device,
      VkBufferCollectionFUCHSIA                   collection,
      VkBufferCollectionPropertiesFUCHSIA*        pProperties,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_FUCHSIA
  
  void PostCallRecordGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
      VkDevice                                    device,
      VkRenderPass                                renderpass,
      VkExtent2D*                                 pMaxWorkgroupSize,
      VkResult                                    result) override;
  
  
  void PostCallRecordGetMemoryRemoteAddressNV(
      VkDevice                                    device,
      const VkMemoryGetRemoteAddressInfoNV*       pMemoryGetRemoteAddressInfo,
      VkRemoteAddressNV*                          pAddress,
      VkResult                                    result) override;
  
  
  #ifdef VK_USE_PLATFORM_SCREEN_QNX
  
  void PostCallRecordCreateScreenSurfaceQNX(
      VkInstance                                  instance,
      const VkScreenSurfaceCreateInfoQNX*         pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkSurfaceKHR*                               pSurface,
      VkResult                                    result) override;
  
  
  #endif // VK_USE_PLATFORM_SCREEN_QNX
  
  void PostCallRecordCreateAccelerationStructureKHR(
      VkDevice                                    device,
      const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
      const VkAllocationCallbacks*                pAllocator,
      VkAccelerationStructureKHR*                 pAccelerationStructure,
      VkResult                                    result) override;
  
  
  void PostCallRecordBuildAccelerationStructuresKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      deferredOperation,
      uint32_t                                    infoCount,
      const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
      const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos,
      VkResult                                    result) override;
  
  
  void PostCallRecordCopyAccelerationStructureKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      deferredOperation,
      const VkCopyAccelerationStructureInfoKHR*   pInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordCopyAccelerationStructureToMemoryKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      deferredOperation,
      const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordCopyMemoryToAccelerationStructureKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      deferredOperation,
      const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo,
      VkResult                                    result) override;
  
  
  void PostCallRecordWriteAccelerationStructuresPropertiesKHR(
      VkDevice                                    device,
      uint32_t                                    accelerationStructureCount,
      const VkAccelerationStructureKHR*           pAccelerationStructures,
      VkQueryType                                 queryType,
      size_t                                      dataSize,
      void*                                       pData,
      size_t                                      stride,
      VkResult                                    result) override;
  
  
  void PostCallRecordCreateRayTracingPipelinesKHR(
      VkDevice                                    device,
      VkDeferredOperationKHR                      deferredOperation,
      VkPipelineCache                             pipelineCache,
      uint32_t                                    createInfoCount,
      const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
      const VkAllocationCallbacks*                pAllocator,
      VkPipeline*                                 pPipelines,
      VkResult                                    result,
      void*                                       state_data) override;
  
  
  void PostCallRecordGetRayTracingCaptureReplayShaderGroupHandlesKHR(
      VkDevice                                    device,
      VkPipeline                                  pipeline,
      uint32_t                                    firstGroup,
      uint32_t                                    groupCount,
      size_t                                      dataSize,
      void*                                       pData,
      VkResult                                    result) override;
  
  
  
  
  
  
  const layer_data::unordered_map<std::string, DeprecationData>  deprecated_extensions = {
      {"VK_AMD_draw_indirect_count", {kExtPromoted, "VK_KHR_draw_indirect_count"}},
      {"VK_AMD_gpu_shader_half_float", {kExtDeprecated, "VK_KHR_shader_float16_int8"}},
      {"VK_AMD_gpu_shader_int16", {kExtDeprecated, "VK_KHR_shader_float16_int8"}},
      {"VK_AMD_negative_viewport_height", {kExtObsoleted, "VK_KHR_maintenance1"}},
      {"VK_EXT_buffer_device_address", {kExtDeprecated, "VK_KHR_buffer_device_address"}},
      {"VK_EXT_debug_marker", {kExtPromoted, "VK_EXT_debug_utils"}},
      {"VK_EXT_debug_report", {kExtDeprecated, "VK_EXT_debug_utils"}},
      {"VK_EXT_descriptor_indexing", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_EXT_host_query_reset", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_EXT_sampler_filter_minmax", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_EXT_scalar_block_layout", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_EXT_separate_stencil_usage", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_EXT_shader_subgroup_ballot", {kExtDeprecated, "VK_VERSION_1_2"}},
      {"VK_EXT_shader_subgroup_vote", {kExtDeprecated, "VK_VERSION_1_1"}},
      {"VK_EXT_shader_viewport_index_layer", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_EXT_validation_flags", {kExtDeprecated, "VK_EXT_validation_features"}},
      {"VK_KHR_16bit_storage", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_8bit_storage", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_bind_memory2", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_buffer_device_address", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_create_renderpass2", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_dedicated_allocation", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_depth_stencil_resolve", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_descriptor_update_template", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_device_group", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_device_group_creation", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_draw_indirect_count", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_driver_properties", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_external_fence", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_external_fence_capabilities", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_external_memory", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_external_memory_capabilities", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_external_semaphore", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_external_semaphore_capabilities", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_get_memory_requirements2", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_get_physical_device_properties2", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_image_format_list", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_imageless_framebuffer", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_maintenance1", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_maintenance2", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_maintenance3", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_multiview", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_relaxed_block_layout", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_sampler_mirror_clamp_to_edge", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_sampler_ycbcr_conversion", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_separate_depth_stencil_layouts", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_shader_atomic_int64", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_shader_draw_parameters", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_shader_float16_int8", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_shader_float_controls", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_shader_subgroup_extended_types", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_spirv_1_4", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_storage_buffer_storage_class", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_timeline_semaphore", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_uniform_buffer_standard_layout", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_KHR_variable_pointers", {kExtPromoted, "VK_VERSION_1_1"}},
      {"VK_KHR_vulkan_memory_model", {kExtPromoted, "VK_VERSION_1_2"}},
      {"VK_MVK_ios_surface", {kExtDeprecated, "VK_EXT_metal_surface"}},
      {"VK_MVK_macos_surface", {kExtDeprecated, "VK_EXT_metal_surface"}},
      {"VK_NV_dedicated_allocation", {kExtDeprecated, "VK_KHR_dedicated_allocation"}},
      {"VK_NV_external_memory", {kExtDeprecated, "VK_KHR_external_memory"}},
      {"VK_NV_external_memory_capabilities", {kExtDeprecated, "VK_KHR_external_memory_capabilities"}},
      {"VK_NV_external_memory_win32", {kExtDeprecated, "VK_KHR_external_memory_win32"}},
      {"VK_NV_glsl_shader", {kExtDeprecated, ""}},
      {"VK_NV_win32_keyed_mutex", {kExtPromoted, "VK_KHR_win32_keyed_mutex"}},
  };
  
  const layer_data::unordered_map<std::string, std::string> special_use_extensions = {
      {"VK_AMD_buffer_marker", "devtools"},
      {"VK_AMD_shader_info", "devtools"},
      {"VK_EXT_border_color_swizzle", "glemulation, d3demulation"},
      {"VK_EXT_custom_border_color", "glemulation, d3demulation"},
      {"VK_EXT_debug_marker", "debugging"},
      {"VK_EXT_debug_report", "debugging"},
      {"VK_EXT_debug_utils", "debugging"},
      {"VK_EXT_depth_clip_enable", "d3demulation"},
      {"VK_EXT_device_memory_report", "devtools"},
      {"VK_EXT_line_rasterization", "cadsupport"},
      {"VK_EXT_pipeline_creation_feedback", "devtools"},
      {"VK_EXT_primitive_topology_list_restart", "glemulation"},
      {"VK_EXT_provoking_vertex", "glemulation"},
      {"VK_EXT_transform_feedback", "glemulation, d3demulation, devtools"},
      {"VK_EXT_validation_features", "debugging"},
      {"VK_EXT_validation_flags", "debugging"},
      {"VK_INTEL_performance_query", "devtools"},
      {"VK_KHR_performance_query", "devtools"},
      {"VK_KHR_pipeline_executable_properties", "devtools"},
      {"VK_VALVE_mutable_descriptor_type", "d3demulation"},
  };
  
  