guest/vulkan_enc/func_table.cpp

// Copyright (C) 2018 The Android Open Source Project
// Copyright (C) 2018 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Autogenerated module func_table
//
// (impl) generated by codegen/vulkan/vulkan-docs-next/scripts/genvk.py -registry
// codegen/vulkan/vulkan-docs-next/xml/vk.xml -registryGfxstream
// codegen/vulkan/vulkan-docs-next/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
//
// Please do not modify directly;
// re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing vk.xml
// VULKAN_REGISTRY_SCRIPTS_DIR : Directory containing genvk.py
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
//
// python3 $VULKAN_REGISTRY_SCRIPTS_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o
// $CEREAL_OUTPUT_DIR
//

#include "func_table.h"

#include <log/log.h>

#include <cstring>

#include "../OpenglSystemCommon/HostConnection.h"
#include "ResourceTracker.h"
#include "VkEncoder.h"
#include "goldfish_vk_private_defs.h"

// Stuff we are not going to use but if included,
// will cause compile errors. These are Android Vulkan
// required extensions, but the approach will be to
// implement them completely on the guest side.
#undef VK_KHR_android_surface
#if defined(LINUX_GUEST_BUILD)
#undef VK_ANDROID_native_buffer
#endif

namespace gfxstream {
namespace vk {

static void sOnInvalidDynamicallyCheckedCall(const char* apiname, const char* neededFeature) {
    ALOGE("invalid call to %s: %s not supported", apiname, neededFeature);
    abort();
}
#ifdef VK_VERSION_1_0
static VkResult entry_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo,
                                       const VkAllocationCallbacks* pAllocator,
                                       VkInstance* pInstance) {
    AEMU_SCOPED_TRACE("vkCreateInstance");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateInstance_VkResult_return = (VkResult)0;
    vkCreateInstance_VkResult_return =
        vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance, true /* do lock */);
    return vkCreateInstance_VkResult_return;
}
static void entry_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyInstance");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyInstance(instance, pAllocator, true /* do lock */);
}
static VkResult entry_vkEnumeratePhysicalDevices(VkInstance instance,
                                                 uint32_t* pPhysicalDeviceCount,
                                                 VkPhysicalDevice* pPhysicalDevices) {
    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(
        vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices);
    return vkEnumeratePhysicalDevices_VkResult_return;
}
static void entry_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
                                              VkPhysicalDeviceFeatures* pFeatures) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
                                                      VkFormat format,
                                                      VkFormatProperties* pFormatProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties,
                                               true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling,
    VkImageUsageFlags usage, VkImageCreateFlags flags,
    VkImageFormatProperties* pImageFormatProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceImageFormatProperties_VkResult_return =
        vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage,
                                                        flags, pImageFormatProperties,
                                                        true /* do lock */);
    return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
}
static void entry_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
                                                VkPhysicalDeviceProperties* pProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
    VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties* pQueueFamilyProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount,
                                                    pQueueFamilyProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMemoryProperties(
    VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties,
                                               true /* do lock */);
}
static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(VkInstance instance, const char* pName) {
    AEMU_SCOPED_TRACE("vkGetInstanceProcAddr");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
    vkGetInstanceProcAddr_PFN_vkVoidFunction_return =
        vkEnc->vkGetInstanceProcAddr(instance, pName, true /* do lock */);
    return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
}
static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(VkDevice device, const char* pName) {
    AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
    vkGetDeviceProcAddr_PFN_vkVoidFunction_return =
        vkEnc->vkGetDeviceProcAddr(device, pName, true /* do lock */);
    return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
}
static VkResult entry_vkCreateDevice(VkPhysicalDevice physicalDevice,
                                     const VkDeviceCreateInfo* pCreateInfo,
                                     const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
    AEMU_SCOPED_TRACE("vkCreateDevice");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateDevice_VkResult_return = (VkResult)0;
    vkCreateDevice_VkResult_return =
        vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice, true /* do lock */);
    return vkCreateDevice_VkResult_return;
}
static void entry_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyDevice");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyDevice(device, pAllocator, true /* do lock */);
}
static VkResult entry_vkEnumerateInstanceExtensionProperties(const char* pLayerName,
                                                             uint32_t* pPropertyCount,
                                                             VkExtensionProperties* pProperties) {
    AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkEnumerateInstanceExtensionProperties_VkResult_return =
        resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName,
                                                             pPropertyCount, pProperties);
    return vkEnumerateInstanceExtensionProperties_VkResult_return;
}
static VkResult entry_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
                                                           const char* pLayerName,
                                                           uint32_t* pPropertyCount,
                                                           VkExtensionProperties* pProperties) {
    AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkEnumerateDeviceExtensionProperties_VkResult_return =
        resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice,
                                                           pLayerName, pPropertyCount, pProperties);
    return vkEnumerateDeviceExtensionProperties_VkResult_return;
}
static VkResult entry_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
                                                         VkLayerProperties* pProperties) {
    AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
    vkEnumerateInstanceLayerProperties_VkResult_return =
        vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties, true /* do lock */);
    return vkEnumerateInstanceLayerProperties_VkResult_return;
}
static VkResult entry_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
                                                       uint32_t* pPropertyCount,
                                                       VkLayerProperties* pProperties) {
    AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
    vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(
        physicalDevice, pPropertyCount, pProperties, true /* do lock */);
    return vkEnumerateDeviceLayerProperties_VkResult_return;
}
static void entry_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
                                   VkQueue* pQueue) {
    AEMU_SCOPED_TRACE("vkGetDeviceQueue");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue, true /* do lock */);
}
static VkResult entry_vkQueueSubmit(VkQueue queue, uint32_t submitCount,
                                    const VkSubmitInfo* pSubmits, VkFence fence) {
    AEMU_SCOPED_TRACE("vkQueueSubmit");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkQueueSubmit_VkResult_return =
        resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
    return vkQueueSubmit_VkResult_return;
}
static VkResult entry_vkQueueWaitIdle(VkQueue queue) {
    AEMU_SCOPED_TRACE("vkQueueWaitIdle");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkQueueWaitIdle_VkResult_return = resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, queue);
    return vkQueueWaitIdle_VkResult_return;
}
static VkResult entry_vkDeviceWaitIdle(VkDevice device) {
    AEMU_SCOPED_TRACE("vkDeviceWaitIdle");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
    vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device, true /* do lock */);
    return vkDeviceWaitIdle_VkResult_return;
}
static VkResult entry_vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
                                       const VkAllocationCallbacks* pAllocator,
                                       VkDeviceMemory* pMemory) {
    AEMU_SCOPED_TRACE("vkAllocateMemory");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(
        vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory);
    return vkAllocateMemory_VkResult_return;
}
static void entry_vkFreeMemory(VkDevice device, VkDeviceMemory memory,
                               const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkFreeMemory");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkFreeMemory(vkEnc, device, memory, pAllocator);
}
static VkResult entry_vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
                                  VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
    AEMU_SCOPED_TRACE("vkMapMemory");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkMapMemory_VkResult_return = (VkResult)0;
    vkMapMemory_VkResult_return =
        vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData, true /* do lock */);
    return vkMapMemory_VkResult_return;
}
static void entry_vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
    AEMU_SCOPED_TRACE("vkUnmapMemory");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkUnmapMemory(device, memory, true /* do lock */);
}
static VkResult entry_vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
                                                const VkMappedMemoryRange* pMemoryRanges) {
    AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
    vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(
        device, memoryRangeCount, pMemoryRanges, true /* do lock */);
    return vkFlushMappedMemoryRanges_VkResult_return;
}
static VkResult entry_vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
                                                     const VkMappedMemoryRange* pMemoryRanges) {
    AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
    vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(
        device, memoryRangeCount, pMemoryRanges, true /* do lock */);
    return vkInvalidateMappedMemoryRanges_VkResult_return;
}
static void entry_vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
                                              VkDeviceSize* pCommittedMemoryInBytes) {
    AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes, true /* do lock */);
}
static VkResult entry_vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
                                         VkDeviceSize memoryOffset) {
    AEMU_SCOPED_TRACE("vkBindBufferMemory");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindBufferMemory_VkResult_return =
        resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset);
    return vkBindBufferMemory_VkResult_return;
}
static VkResult entry_vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory,
                                        VkDeviceSize memoryOffset) {
    AEMU_SCOPED_TRACE("vkBindImageMemory");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindImageMemory_VkResult_return =
        resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset);
    return vkBindImageMemory_VkResult_return;
}
static void entry_vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
                                                VkMemoryRequirements* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetBufferMemoryRequirements(vkEnc, device, buffer, pMemoryRequirements);
}
static void entry_vkGetImageMemoryRequirements(VkDevice device, VkImage image,
                                               VkMemoryRequirements* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetImageMemoryRequirements(vkEnc, device, image, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements(
    VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount,
                                              pSparseMemoryRequirements, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
    VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
    VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling,
    uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples,
                                                          usage, tiling, pPropertyCount,
                                                          pProperties, true /* do lock */);
}
static VkResult entry_vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
                                        const VkBindSparseInfo* pBindInfo, VkFence fence) {
    AEMU_SCOPED_TRACE("vkQueueBindSparse");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
    vkQueueBindSparse_VkResult_return =
        vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
    return vkQueueBindSparse_VkResult_return;
}
static VkResult entry_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo,
                                    const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
    AEMU_SCOPED_TRACE("vkCreateFence");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateFence_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateFence_VkResult_return =
        resources->on_vkCreateFence(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pFence);
    return vkCreateFence_VkResult_return;
}
static void entry_vkDestroyFence(VkDevice device, VkFence fence,
                                 const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyFence");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyFence(device, fence, pAllocator, true /* do lock */);
}
static VkResult entry_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
    AEMU_SCOPED_TRACE("vkResetFences");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkResetFences_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkResetFences_VkResult_return =
        resources->on_vkResetFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences);
    return vkResetFences_VkResult_return;
}
static VkResult entry_vkGetFenceStatus(VkDevice device, VkFence fence) {
    AEMU_SCOPED_TRACE("vkGetFenceStatus");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
    vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence, true /* do lock */);
    return vkGetFenceStatus_VkResult_return;
}
static VkResult entry_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences,
                                      VkBool32 waitAll, uint64_t timeout) {
    AEMU_SCOPED_TRACE("vkWaitForFences");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkWaitForFences_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkWaitForFences_VkResult_return = resources->on_vkWaitForFences(
        vkEnc, VK_SUCCESS, device, fenceCount, pFences, waitAll, timeout);
    return vkWaitForFences_VkResult_return;
}
static VkResult entry_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
                                        const VkAllocationCallbacks* pAllocator,
                                        VkSemaphore* pSemaphore) {
    AEMU_SCOPED_TRACE("vkCreateSemaphore");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(
        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore);
    return vkCreateSemaphore_VkResult_return;
}
static void entry_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
                                     const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroySemaphore");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroySemaphore(vkEnc, device, semaphore, pAllocator);
}
static VkResult entry_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo,
                                    const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
    AEMU_SCOPED_TRACE("vkCreateEvent");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateEvent_VkResult_return = (VkResult)0;
    vkCreateEvent_VkResult_return =
        vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent, true /* do lock */);
    return vkCreateEvent_VkResult_return;
}
static void entry_vkDestroyEvent(VkDevice device, VkEvent event,
                                 const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyEvent");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyEvent(device, event, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetEventStatus(VkDevice device, VkEvent event) {
    AEMU_SCOPED_TRACE("vkGetEventStatus");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
    vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event, true /* do lock */);
    return vkGetEventStatus_VkResult_return;
}
static VkResult entry_vkSetEvent(VkDevice device, VkEvent event) {
    AEMU_SCOPED_TRACE("vkSetEvent");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkSetEvent_VkResult_return = (VkResult)0;
    vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event, true /* do lock */);
    return vkSetEvent_VkResult_return;
}
static VkResult entry_vkResetEvent(VkDevice device, VkEvent event) {
    AEMU_SCOPED_TRACE("vkResetEvent");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkResetEvent_VkResult_return = (VkResult)0;
    vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event, true /* do lock */);
    return vkResetEvent_VkResult_return;
}
static VkResult entry_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
                                        const VkAllocationCallbacks* pAllocator,
                                        VkQueryPool* pQueryPool) {
    AEMU_SCOPED_TRACE("vkCreateQueryPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
    vkCreateQueryPool_VkResult_return =
        vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool, true /* do lock */);
    return vkCreateQueryPool_VkResult_return;
}
static void entry_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
                                     const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyQueryPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
                                            uint32_t firstQuery, uint32_t queryCount,
                                            size_t dataSize, void* pData, VkDeviceSize stride,
                                            VkQueryResultFlags flags) {
    AEMU_SCOPED_TRACE("vkGetQueryPoolResults");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
    vkGetQueryPoolResults_VkResult_return =
        vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData,
                                     stride, flags, true /* do lock */);
    return vkGetQueryPoolResults_VkResult_return;
}
static VkResult entry_vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
                                     const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
    AEMU_SCOPED_TRACE("vkCreateBuffer");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateBuffer_VkResult_return =
        resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer);
    return vkCreateBuffer_VkResult_return;
}
static void entry_vkDestroyBuffer(VkDevice device, VkBuffer buffer,
                                  const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyBuffer");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroyBuffer(vkEnc, device, buffer, pAllocator);
}
static VkResult entry_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
                                         const VkAllocationCallbacks* pAllocator,
                                         VkBufferView* pView) {
    AEMU_SCOPED_TRACE("vkCreateBufferView");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
    vkCreateBufferView_VkResult_return =
        vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView, true /* do lock */);
    return vkCreateBufferView_VkResult_return;
}
static void entry_vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
                                      const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyBufferView");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyBufferView(device, bufferView, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
                                    const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
    AEMU_SCOPED_TRACE("vkCreateImage");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateImage_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateImage_VkResult_return =
        resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage);
    return vkCreateImage_VkResult_return;
}
static void entry_vkDestroyImage(VkDevice device, VkImage image,
                                 const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyImage");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroyImage(vkEnc, device, image, pAllocator);
}
static void entry_vkGetImageSubresourceLayout(VkDevice device, VkImage image,
                                              const VkImageSubresource* pSubresource,
                                              VkSubresourceLayout* pLayout) {
    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout, true /* do lock */);
}
static VkResult entry_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
                                        const VkAllocationCallbacks* pAllocator,
                                        VkImageView* pView) {
    AEMU_SCOPED_TRACE("vkCreateImageView");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateImageView_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateImageView_VkResult_return =
        resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView);
    return vkCreateImageView_VkResult_return;
}
static void entry_vkDestroyImageView(VkDevice device, VkImageView imageView,
                                     const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyImageView");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyImageView(device, imageView, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateShaderModule(VkDevice device,
                                           const VkShaderModuleCreateInfo* pCreateInfo,
                                           const VkAllocationCallbacks* pAllocator,
                                           VkShaderModule* pShaderModule) {
    AEMU_SCOPED_TRACE("vkCreateShaderModule");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
    vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(
        device, pCreateInfo, pAllocator, pShaderModule, true /* do lock */);
    return vkCreateShaderModule_VkResult_return;
}
static void entry_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
                                        const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyShaderModule");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreatePipelineCache(VkDevice device,
                                            const VkPipelineCacheCreateInfo* pCreateInfo,
                                            const VkAllocationCallbacks* pAllocator,
                                            VkPipelineCache* pPipelineCache) {
    AEMU_SCOPED_TRACE("vkCreatePipelineCache");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
    vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(
        device, pCreateInfo, pAllocator, pPipelineCache, true /* do lock */);
    return vkCreatePipelineCache_VkResult_return;
}
static void entry_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
                                         const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
                                             size_t* pDataSize, void* pData) {
    AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
    vkGetPipelineCacheData_VkResult_return =
        vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData, true /* do lock */);
    return vkGetPipelineCacheData_VkResult_return;
}
static VkResult entry_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
                                            uint32_t srcCacheCount,
                                            const VkPipelineCache* pSrcCaches) {
    AEMU_SCOPED_TRACE("vkMergePipelineCaches");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
    vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(
        device, dstCache, srcCacheCount, pSrcCaches, true /* do lock */);
    return vkMergePipelineCaches_VkResult_return;
}
static VkResult entry_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
                                                uint32_t createInfoCount,
                                                const VkGraphicsPipelineCreateInfo* pCreateInfos,
                                                const VkAllocationCallbacks* pAllocator,
                                                VkPipeline* pPipelines) {
    AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateGraphicsPipelines_VkResult_return = resources->on_vkCreateGraphicsPipelines(
        vkEnc, VK_SUCCESS, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
        pPipelines);
    return vkCreateGraphicsPipelines_VkResult_return;
}
static VkResult entry_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
                                               uint32_t createInfoCount,
                                               const VkComputePipelineCreateInfo* pCreateInfos,
                                               const VkAllocationCallbacks* pAllocator,
                                               VkPipeline* pPipelines) {
    AEMU_SCOPED_TRACE("vkCreateComputePipelines");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
    vkCreateComputePipelines_VkResult_return =
        vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos,
                                        pAllocator, pPipelines, true /* do lock */);
    return vkCreateComputePipelines_VkResult_return;
}
static void entry_vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
                                    const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyPipeline");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyPipeline(device, pipeline, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreatePipelineLayout(VkDevice device,
                                             const VkPipelineLayoutCreateInfo* pCreateInfo,
                                             const VkAllocationCallbacks* pAllocator,
                                             VkPipelineLayout* pPipelineLayout) {
    AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
    vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(
        device, pCreateInfo, pAllocator, pPipelineLayout, true /* do lock */);
    return vkCreatePipelineLayout_VkResult_return;
}
static void entry_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
                                          const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
                                      const VkAllocationCallbacks* pAllocator,
                                      VkSampler* pSampler) {
    AEMU_SCOPED_TRACE("vkCreateSampler");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateSampler_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateSampler_VkResult_return =
        resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
    return vkCreateSampler_VkResult_return;
}
static void entry_vkDestroySampler(VkDevice device, VkSampler sampler,
                                   const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroySampler");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroySampler(device, sampler, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateDescriptorSetLayout(
    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
    AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(
        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSetLayout);
    return vkCreateDescriptorSetLayout_VkResult_return;
}
static void entry_vkDestroyDescriptorSetLayout(VkDevice device,
                                               VkDescriptorSetLayout descriptorSetLayout,
                                               const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroyDescriptorSetLayout(vkEnc, device, descriptorSetLayout, pAllocator);
}
static VkResult entry_vkCreateDescriptorPool(VkDevice device,
                                             const VkDescriptorPoolCreateInfo* pCreateInfo,
                                             const VkAllocationCallbacks* pAllocator,
                                             VkDescriptorPool* pDescriptorPool) {
    AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(
        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pDescriptorPool);
    return vkCreateDescriptorPool_VkResult_return;
}
static void entry_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                          const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyDescriptorPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroyDescriptorPool(vkEnc, device, descriptorPool, pAllocator);
}
static VkResult entry_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                            VkDescriptorPoolResetFlags flags) {
    AEMU_SCOPED_TRACE("vkResetDescriptorPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkResetDescriptorPool_VkResult_return =
        resources->on_vkResetDescriptorPool(vkEnc, VK_SUCCESS, device, descriptorPool, flags);
    return vkResetDescriptorPool_VkResult_return;
}
static VkResult entry_vkAllocateDescriptorSets(VkDevice device,
                                               const VkDescriptorSetAllocateInfo* pAllocateInfo,
                                               VkDescriptorSet* pDescriptorSets) {
    AEMU_SCOPED_TRACE("vkAllocateDescriptorSets");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(
        vkEnc, VK_SUCCESS, device, pAllocateInfo, pDescriptorSets);
    return vkAllocateDescriptorSets_VkResult_return;
}
static VkResult entry_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
                                           uint32_t descriptorSetCount,
                                           const VkDescriptorSet* pDescriptorSets) {
    AEMU_SCOPED_TRACE("vkFreeDescriptorSets");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(
        vkEnc, VK_SUCCESS, device, descriptorPool, descriptorSetCount, pDescriptorSets);
    return vkFreeDescriptorSets_VkResult_return;
}
static void entry_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
                                         const VkWriteDescriptorSet* pDescriptorWrites,
                                         uint32_t descriptorCopyCount,
                                         const VkCopyDescriptorSet* pDescriptorCopies) {
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSets");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkUpdateDescriptorSets(vkEnc, device, descriptorWriteCount, pDescriptorWrites,
                                         descriptorCopyCount, pDescriptorCopies);
}
static VkResult entry_vkCreateFramebuffer(VkDevice device,
                                          const VkFramebufferCreateInfo* pCreateInfo,
                                          const VkAllocationCallbacks* pAllocator,
                                          VkFramebuffer* pFramebuffer) {
    AEMU_SCOPED_TRACE("vkCreateFramebuffer");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
    vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(
        device, pCreateInfo, pAllocator, pFramebuffer, true /* do lock */);
    return vkCreateFramebuffer_VkResult_return;
}
static void entry_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
                                       const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator, true /* do lock */);
}
static VkResult entry_vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
                                         const VkAllocationCallbacks* pAllocator,
                                         VkRenderPass* pRenderPass) {
    AEMU_SCOPED_TRACE("vkCreateRenderPass");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
    vkCreateRenderPass_VkResult_return =
        vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
    return vkCreateRenderPass_VkResult_return;
}
static void entry_vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
                                      const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyRenderPass");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator, true /* do lock */);
}
static void entry_vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
                                             VkExtent2D* pGranularity) {
    AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity, true /* do lock */);
}
static VkResult entry_vkCreateCommandPool(VkDevice device,
                                          const VkCommandPoolCreateInfo* pCreateInfo,
                                          const VkAllocationCallbacks* pAllocator,
                                          VkCommandPool* pCommandPool) {
    AEMU_SCOPED_TRACE("vkCreateCommandPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
    vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(
        device, pCreateInfo, pAllocator, pCommandPool, true /* do lock */);
    return vkCreateCommandPool_VkResult_return;
}
static void entry_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
                                       const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyCommandPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator, true /* do lock */);
}
static VkResult entry_vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
                                         VkCommandPoolResetFlags flags) {
    AEMU_SCOPED_TRACE("vkResetCommandPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
    vkResetCommandPool_VkResult_return =
        vkEnc->vkResetCommandPool(device, commandPool, flags, true /* do lock */);
    if (vkResetCommandPool_VkResult_return == VK_SUCCESS) {
        ResourceTracker::get()->resetCommandPoolStagingInfo(commandPool);
    }
    return vkResetCommandPool_VkResult_return;
}
static VkResult entry_vkAllocateCommandBuffers(VkDevice device,
                                               const VkCommandBufferAllocateInfo* pAllocateInfo,
                                               VkCommandBuffer* pCommandBuffers) {
    AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkAllocateCommandBuffers_VkResult_return = resources->on_vkAllocateCommandBuffers(
        vkEnc, VK_SUCCESS, device, pAllocateInfo, pCommandBuffers);
    if (vkAllocateCommandBuffers_VkResult_return == VK_SUCCESS) {
        ResourceTracker::get()->addToCommandPool(
            pAllocateInfo->commandPool, pAllocateInfo->commandBufferCount, pCommandBuffers);
    }
    return vkAllocateCommandBuffers_VkResult_return;
}
static void entry_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
                                       uint32_t commandBufferCount,
                                       const VkCommandBuffer* pCommandBuffers) {
    AEMU_SCOPED_TRACE("vkFreeCommandBuffers");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers,
                                true /* do lock */);
}
static VkResult entry_vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
                                           const VkCommandBufferBeginInfo* pBeginInfo) {
    AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBeginCommandBuffer_VkResult_return =
        resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
    return vkBeginCommandBuffer_VkResult_return;
}
static VkResult entry_vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
    AEMU_SCOPED_TRACE("vkEndCommandBuffer");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkEndCommandBuffer_VkResult_return =
        resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
    return vkEndCommandBuffer_VkResult_return;
}
static VkResult entry_vkResetCommandBuffer(VkCommandBuffer commandBuffer,
                                           VkCommandBufferResetFlags flags) {
    AEMU_SCOPED_TRACE("vkResetCommandBuffer");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkResetCommandBuffer_VkResult_return =
        resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
    return vkResetCommandBuffer_VkResult_return;
}
static void entry_vkCmdBindPipeline(VkCommandBuffer commandBuffer,
                                    VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
    AEMU_SCOPED_TRACE("vkCmdBindPipeline");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline, true /* do lock */);
}
static void entry_vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
                                   uint32_t viewportCount, const VkViewport* pViewports) {
    AEMU_SCOPED_TRACE("vkCmdSetViewport");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports,
                            true /* do lock */);
}
static void entry_vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
                                  uint32_t scissorCount, const VkRect2D* pScissors) {
    AEMU_SCOPED_TRACE("vkCmdSetScissor");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors,
                           true /* do lock */);
}
static void entry_vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
    AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth, true /* do lock */);
}
static void entry_vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
                                    float depthBiasClamp, float depthBiasSlopeFactor) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp,
                             depthBiasSlopeFactor, true /* do lock */);
}
static void entry_vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
                                         const float blendConstants[4]) {
    AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants, true /* do lock */);
}
static void entry_vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
                                      float maxDepthBounds) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds, true /* do lock */);
}
static void entry_vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
                                             VkStencilFaceFlags faceMask, uint32_t compareMask) {
    AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask, true /* do lock */);
}
static void entry_vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
                                           VkStencilFaceFlags faceMask, uint32_t writeMask) {
    AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask, true /* do lock */);
}
static void entry_vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
                                           VkStencilFaceFlags faceMask, uint32_t reference) {
    AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference, true /* do lock */);
}
static void entry_vkCmdBindDescriptorSets(
    VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
    uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
    uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
    AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    auto resources = ResourceTracker::get();
    resources->on_vkCmdBindDescriptorSets(vkEnc, commandBuffer, pipelineBindPoint, layout, firstSet,
                                          descriptorSetCount, pDescriptorSets, dynamicOffsetCount,
                                          pDynamicOffsets);
}
static void entry_vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                       VkDeviceSize offset, VkIndexType indexType) {
    AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType, true /* do lock */);
}
static void entry_vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
                                         uint32_t bindingCount, const VkBuffer* pBuffers,
                                         const VkDeviceSize* pOffsets) {
    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
                                  true /* do lock */);
}
static void entry_vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
                            uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
    AEMU_SCOPED_TRACE("vkCmdDraw");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance,
                     true /* do lock */);
}
static void entry_vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
                                   uint32_t instanceCount, uint32_t firstIndex,
                                   int32_t vertexOffset, uint32_t firstInstance) {
    AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset,
                            firstInstance, true /* do lock */);
}
static void entry_vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                    VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
    AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride, true /* do lock */);
}
static void entry_vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                           VkDeviceSize offset, uint32_t drawCount,
                                           uint32_t stride) {
    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride,
                                    true /* do lock */);
}
static void entry_vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX,
                                uint32_t groupCountY, uint32_t groupCountZ) {
    AEMU_SCOPED_TRACE("vkCmdDispatch");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ, true /* do lock */);
}
static void entry_vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                        VkDeviceSize offset) {
    AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset, true /* do lock */);
}
static void entry_vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
                                  VkBuffer dstBuffer, uint32_t regionCount,
                                  const VkBufferCopy* pRegions) {
    AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions,
                           true /* do lock */);
}
static void entry_vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
                                 VkImageLayout srcImageLayout, VkImage dstImage,
                                 VkImageLayout dstImageLayout, uint32_t regionCount,
                                 const VkImageCopy* pRegions) {
    AEMU_SCOPED_TRACE("vkCmdCopyImage");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
                          regionCount, pRegions, true /* do lock */);
}
static void entry_vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
                                 VkImageLayout srcImageLayout, VkImage dstImage,
                                 VkImageLayout dstImageLayout, uint32_t regionCount,
                                 const VkImageBlit* pRegions, VkFilter filter) {
    AEMU_SCOPED_TRACE("vkCmdBlitImage");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
                          regionCount, pRegions, filter, true /* do lock */);
}
static void entry_vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
                                         VkImage dstImage, VkImageLayout dstImageLayout,
                                         uint32_t regionCount, const VkBufferImageCopy* pRegions) {
    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
                                  pRegions, true /* do lock */);
}
static void entry_vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
                                         VkImageLayout srcImageLayout, VkBuffer dstBuffer,
                                         uint32_t regionCount, const VkBufferImageCopy* pRegions) {
    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
                                  pRegions, true /* do lock */);
}
static void entry_vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
                                    VkDeviceSize dstOffset, VkDeviceSize dataSize,
                                    const void* pData) {
    AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData,
                             true /* do lock */);
}
static void entry_vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
                                  VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
    AEMU_SCOPED_TRACE("vkCmdFillBuffer");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data, true /* do lock */);
}
static void entry_vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
                                       VkImageLayout imageLayout, const VkClearColorValue* pColor,
                                       uint32_t rangeCount,
                                       const VkImageSubresourceRange* pRanges) {
    AEMU_SCOPED_TRACE("vkCmdClearColorImage");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges,
                                true /* do lock */);
}
static void entry_vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
                                              VkImageLayout imageLayout,
                                              const VkClearDepthStencilValue* pDepthStencil,
                                              uint32_t rangeCount,
                                              const VkImageSubresourceRange* pRanges) {
    AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
                                       pRanges, true /* do lock */);
}
static void entry_vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
                                        const VkClearAttachment* pAttachments, uint32_t rectCount,
                                        const VkClearRect* pRects) {
    AEMU_SCOPED_TRACE("vkCmdClearAttachments");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects,
                                 true /* do lock */);
}
static void entry_vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
                                    VkImageLayout srcImageLayout, VkImage dstImage,
                                    VkImageLayout dstImageLayout, uint32_t regionCount,
                                    const VkImageResolve* pRegions) {
    AEMU_SCOPED_TRACE("vkCmdResolveImage");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
                             regionCount, pRegions, true /* do lock */);
}
static void entry_vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
                                VkPipelineStageFlags stageMask) {
    AEMU_SCOPED_TRACE("vkCmdSetEvent");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask, true /* do lock */);
}
static void entry_vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
                                  VkPipelineStageFlags stageMask) {
    AEMU_SCOPED_TRACE("vkCmdResetEvent");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask, true /* do lock */);
}
static void entry_vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
                                  const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
                                  VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
                                  const VkMemoryBarrier* pMemoryBarriers,
                                  uint32_t bufferMemoryBarrierCount,
                                  const VkBufferMemoryBarrier* pBufferMemoryBarriers,
                                  uint32_t imageMemoryBarrierCount,
                                  const VkImageMemoryBarrier* pImageMemoryBarriers) {
    AEMU_SCOPED_TRACE("vkCmdWaitEvents");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask,
                           memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
                           pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers,
                           true /* do lock */);
}
static void entry_vkCmdPipelineBarrier(
    VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
    VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
    uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
    uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
    uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    auto resources = ResourceTracker::get();
    resources->on_vkCmdPipelineBarrier(vkEnc, commandBuffer, srcStageMask, dstStageMask,
                                       dependencyFlags, memoryBarrierCount, pMemoryBarriers,
                                       bufferMemoryBarrierCount, pBufferMemoryBarriers,
                                       imageMemoryBarrierCount, pImageMemoryBarriers);
}
static void entry_vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                  uint32_t query, VkQueryControlFlags flags) {
    AEMU_SCOPED_TRACE("vkCmdBeginQuery");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags, true /* do lock */);
}
static void entry_vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                uint32_t query) {
    AEMU_SCOPED_TRACE("vkCmdEndQuery");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query, true /* do lock */);
}
static void entry_vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                      uint32_t firstQuery, uint32_t queryCount) {
    AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount,
                               true /* do lock */);
}
static void entry_vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
                                      VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool,
                                      uint32_t query) {
    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query, true /* do lock */);
}
static void entry_vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                            uint32_t firstQuery, uint32_t queryCount,
                                            VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                            VkDeviceSize stride, VkQueryResultFlags flags) {
    AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer,
                                     dstOffset, stride, flags, true /* do lock */);
}
static void entry_vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
                                     VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size,
                                     const void* pValues) {
    AEMU_SCOPED_TRACE("vkCmdPushConstants");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues,
                              true /* do lock */);
}
static void entry_vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
                                       const VkRenderPassBeginInfo* pRenderPassBegin,
                                       VkSubpassContents contents) {
    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents, true /* do lock */);
}
static void entry_vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
    AEMU_SCOPED_TRACE("vkCmdNextSubpass");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdNextSubpass(commandBuffer, contents, true /* do lock */);
}
static void entry_vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
    AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndRenderPass(commandBuffer, true /* do lock */);
}
static void entry_vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount,
                                       const VkCommandBuffer* pCommandBuffers) {
    AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    auto resources = ResourceTracker::get();
    resources->on_vkCmdExecuteCommands(vkEnc, commandBuffer, commandBufferCount, pCommandBuffers);
}
#endif
#ifdef VK_VERSION_1_1
static VkResult entry_vkEnumerateInstanceVersion(uint32_t* pApiVersion) {
    AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
    vkEnumerateInstanceVersion_VkResult_return =
        vkEnc->vkEnumerateInstanceVersion(pApiVersion, true /* do lock */);
    return vkEnumerateInstanceVersion_VkResult_return;
}
static VkResult entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
                                          const VkBindBufferMemoryInfo* pBindInfos) {
    AEMU_SCOPED_TRACE("vkBindBufferMemory2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindBufferMemory2_VkResult_return =
        resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindBufferMemory2_VkResult_return;
}
static VkResult dynCheck_entry_vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
                                                   const VkBindBufferMemoryInfo* pBindInfos) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkBindBufferMemory2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
    vkBindBufferMemory2_VkResult_return =
        resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindBufferMemory2_VkResult_return;
}
static VkResult entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
                                         const VkBindImageMemoryInfo* pBindInfos) {
    AEMU_SCOPED_TRACE("vkBindImageMemory2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindImageMemory2_VkResult_return =
        resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindImageMemory2_VkResult_return;
}
static VkResult dynCheck_entry_vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
                                                  const VkBindImageMemoryInfo* pBindInfos) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkBindImageMemory2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
    vkBindImageMemory2_VkResult_return =
        resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindImageMemory2_VkResult_return;
}
static void entry_vkGetDeviceGroupPeerMemoryFeatures(
    VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
                                              remoteDeviceIndex, pPeerMemoryFeatures,
                                              true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures(
    VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeatures", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex,
                                              remoteDeviceIndex, pPeerMemoryFeatures,
                                              true /* do lock */);
}
static void entry_vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) {
    AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask, true /* do lock */);
}
static void entry_vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX,
                                    uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX,
                                    uint32_t groupCountY, uint32_t groupCountZ) {
    AEMU_SCOPED_TRACE("vkCmdDispatchBase");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX,
                             groupCountY, groupCountZ, true /* do lock */);
}
static VkResult entry_vkEnumeratePhysicalDeviceGroups(
    VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) {
    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
    vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(
        instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties, true /* do lock */);
    return vkEnumeratePhysicalDeviceGroups_VkResult_return;
}
static void entry_vkGetImageMemoryRequirements2(VkDevice device,
                                                const VkImageMemoryRequirementsInfo2* pInfo,
                                                VkMemoryRequirements2* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetImageMemoryRequirements2(
    VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetBufferMemoryRequirements2(VkDevice device,
                                                 const VkBufferMemoryRequirementsInfo2* pInfo,
                                                 VkMemoryRequirements2* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetBufferMemoryRequirements2(
    VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements2(
    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
                                               pSparseMemoryRequirements, true /* do lock */);
}
static void dynCheck_entry_vkGetImageSparseMemoryRequirements2(
    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount,
                                               pSparseMemoryRequirements, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice,
                                               VkPhysicalDeviceFeatures2* pFeatures) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice,
                                                 VkPhysicalDeviceProperties2* pProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice,
                                                       VkFormat format,
                                                       VkFormatProperties2* pFormatProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties,
                                                true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkGetPhysicalDeviceImageFormatProperties2_VkResult_return =
        resources->on_vkGetPhysicalDeviceImageFormatProperties2(
            vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
    return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
    VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount,
                                                     pQueueFamilyProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMemoryProperties2(
    VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties,
                                                true /* do lock */);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(
        physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
}
static void entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
                                    VkCommandPoolTrimFlags flags) {
    AEMU_SCOPED_TRACE("vkTrimCommandPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
}
static void dynCheck_entry_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool,
                                             VkCommandPoolTrimFlags flags) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkTrimCommandPool", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkTrimCommandPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkTrimCommandPool(device, commandPool, flags, true /* do lock */);
}
static void entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
                                    VkQueue* pQueue) {
    AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo,
                                             VkQueue* pQueue) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceQueue2", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue, true /* do lock */);
}
static VkResult entry_vkCreateSamplerYcbcrConversion(
    VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
    return vkCreateSamplerYcbcrConversion_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversion(
    VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversion", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
    vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(
        vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
    return vkCreateSamplerYcbcrConversion_VkResult_return;
}
static void entry_vkDestroySamplerYcbcrConversion(VkDevice device,
                                                  VkSamplerYcbcrConversion ycbcrConversion,
                                                  const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
}
static void dynCheck_entry_vkDestroySamplerYcbcrConversion(
    VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversion", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
}
static VkResult entry_vkCreateDescriptorUpdateTemplate(
    VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
    vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
        device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
    return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplate(
    VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplate", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplate");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
    vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(
        device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, true /* do lock */);
    return vkCreateDescriptorUpdateTemplate_VkResult_return;
}
static void entry_vkDestroyDescriptorUpdateTemplate(
    VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
                                             true /* do lock */);
}
static void dynCheck_entry_vkDestroyDescriptorUpdateTemplate(
    VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplate", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator,
                                             true /* do lock */);
}
static void entry_vkUpdateDescriptorSetWithTemplate(
    VkDevice device, VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
                                                    descriptorUpdateTemplate, pData);
}
static void dynCheck_entry_vkUpdateDescriptorSetWithTemplate(
    VkDevice device, VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplate", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet,
                                                    descriptorUpdateTemplate, pData);
}
static void entry_vkGetPhysicalDeviceExternalBufferProperties(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetPhysicalDeviceExternalBufferProperties(
        vkEnc, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
static void entry_vkGetPhysicalDeviceExternalFenceProperties(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetPhysicalDeviceExternalFenceProperties(
        vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(
        physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
}
static void entry_vkGetDescriptorSetLayoutSupport(
    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport) {
    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
}
static void dynCheck_entry_vkGetDescriptorSetLayoutSupport(
    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1) {
        sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupport", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport, true /* do lock */);
}
#endif
#ifdef VK_VERSION_1_2
static void entry_vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                         VkDeviceSize offset, VkBuffer countBuffer,
                                         VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                         uint32_t stride) {
    AEMU_SCOPED_TRACE("vkCmdDrawIndirectCount");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset,
                                  maxDrawCount, stride, true /* do lock */);
}
static void entry_vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                VkDeviceSize offset, VkBuffer countBuffer,
                                                VkDeviceSize countBufferOffset,
                                                uint32_t maxDrawCount, uint32_t stride) {
    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirectCount");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer,
                                         countBufferOffset, maxDrawCount, stride,
                                         true /* do lock */);
}
static VkResult entry_vkCreateRenderPass2(VkDevice device,
                                          const VkRenderPassCreateInfo2* pCreateInfo,
                                          const VkAllocationCallbacks* pAllocator,
                                          VkRenderPass* pRenderPass) {
    AEMU_SCOPED_TRACE("vkCreateRenderPass2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
    vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
        device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
    return vkCreateRenderPass2_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateRenderPass2(VkDevice device,
                                                   const VkRenderPassCreateInfo2* pCreateInfo,
                                                   const VkAllocationCallbacks* pAllocator,
                                                   VkRenderPass* pRenderPass) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
        sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2", "VK_VERSION_1_2");
    }
    AEMU_SCOPED_TRACE("vkCreateRenderPass2");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateRenderPass2_VkResult_return = (VkResult)0;
    vkCreateRenderPass2_VkResult_return = vkEnc->vkCreateRenderPass2(
        device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
    return vkCreateRenderPass2_VkResult_return;
}
static void entry_vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer,
                                        const VkRenderPassBeginInfo* pRenderPassBegin,
                                        const VkSubpassBeginInfo* pSubpassBeginInfo) {
    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
                                 true /* do lock */);
}
static void entry_vkCmdNextSubpass2(VkCommandBuffer commandBuffer,
                                    const VkSubpassBeginInfo* pSubpassBeginInfo,
                                    const VkSubpassEndInfo* pSubpassEndInfo) {
    AEMU_SCOPED_TRACE("vkCmdNextSubpass2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo, true /* do lock */);
}
static void entry_vkCmdEndRenderPass2(VkCommandBuffer commandBuffer,
                                      const VkSubpassEndInfo* pSubpassEndInfo) {
    AEMU_SCOPED_TRACE("vkCmdEndRenderPass2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo, true /* do lock */);
}
static void entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
                                   uint32_t queryCount) {
    AEMU_SCOPED_TRACE("vkResetQueryPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
static void dynCheck_entry_vkResetQueryPool(VkDevice device, VkQueryPool queryPool,
                                            uint32_t firstQuery, uint32_t queryCount) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
        sOnInvalidDynamicallyCheckedCall("vkResetQueryPool", "VK_VERSION_1_2");
    }
    AEMU_SCOPED_TRACE("vkResetQueryPool");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkResetQueryPool(device, queryPool, firstQuery, queryCount, true /* do lock */);
}
static VkResult entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
                                                 uint64_t* pValue) {
    AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
    vkGetSemaphoreCounterValue_VkResult_return =
        vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
    return vkGetSemaphoreCounterValue_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore,
                                                          uint64_t* pValue) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
        sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreCounterValue", "VK_VERSION_1_2");
    }
    AEMU_SCOPED_TRACE("vkGetSemaphoreCounterValue");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSemaphoreCounterValue_VkResult_return = (VkResult)0;
    vkGetSemaphoreCounterValue_VkResult_return =
        vkEnc->vkGetSemaphoreCounterValue(device, semaphore, pValue, true /* do lock */);
    return vkGetSemaphoreCounterValue_VkResult_return;
}
static VkResult entry_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo,
                                       uint64_t timeout) {
    AEMU_SCOPED_TRACE("vkWaitSemaphores");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
    vkWaitSemaphores_VkResult_return =
        vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
    return vkWaitSemaphores_VkResult_return;
}
static VkResult dynCheck_entry_vkWaitSemaphores(VkDevice device,
                                                const VkSemaphoreWaitInfo* pWaitInfo,
                                                uint64_t timeout) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
        sOnInvalidDynamicallyCheckedCall("vkWaitSemaphores", "VK_VERSION_1_2");
    }
    AEMU_SCOPED_TRACE("vkWaitSemaphores");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkWaitSemaphores_VkResult_return = (VkResult)0;
    vkWaitSemaphores_VkResult_return =
        vkEnc->vkWaitSemaphores(device, pWaitInfo, timeout, true /* do lock */);
    return vkWaitSemaphores_VkResult_return;
}
static VkResult entry_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) {
    AEMU_SCOPED_TRACE("vkSignalSemaphore");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
    vkSignalSemaphore_VkResult_return =
        vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
    return vkSignalSemaphore_VkResult_return;
}
static VkResult dynCheck_entry_vkSignalSemaphore(VkDevice device,
                                                 const VkSemaphoreSignalInfo* pSignalInfo) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
        sOnInvalidDynamicallyCheckedCall("vkSignalSemaphore", "VK_VERSION_1_2");
    }
    AEMU_SCOPED_TRACE("vkSignalSemaphore");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkSignalSemaphore_VkResult_return = (VkResult)0;
    vkSignalSemaphore_VkResult_return =
        vkEnc->vkSignalSemaphore(device, pSignalInfo, true /* do lock */);
    return vkSignalSemaphore_VkResult_return;
}
static VkDeviceAddress entry_vkGetBufferDeviceAddress(VkDevice device,
                                                      const VkBufferDeviceAddressInfo* pInfo) {
    AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
    vkGetBufferDeviceAddress_VkDeviceAddress_return =
        vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
    return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddress(
    VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
        sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddress", "VK_VERSION_1_2");
    }
    AEMU_SCOPED_TRACE("vkGetBufferDeviceAddress");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkDeviceAddress vkGetBufferDeviceAddress_VkDeviceAddress_return = (VkDeviceAddress)0;
    vkGetBufferDeviceAddress_VkDeviceAddress_return =
        vkEnc->vkGetBufferDeviceAddress(device, pInfo, true /* do lock */);
    return vkGetBufferDeviceAddress_VkDeviceAddress_return;
}
static uint64_t entry_vkGetBufferOpaqueCaptureAddress(VkDevice device,
                                                      const VkBufferDeviceAddressInfo* pInfo) {
    AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
    vkGetBufferOpaqueCaptureAddress_uint64_t_return =
        vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
    return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddress(
    VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
        sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddress", "VK_VERSION_1_2");
    }
    AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddress");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    uint64_t vkGetBufferOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
    vkGetBufferOpaqueCaptureAddress_uint64_t_return =
        vkEnc->vkGetBufferOpaqueCaptureAddress(device, pInfo, true /* do lock */);
    return vkGetBufferOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddress(
    VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
    AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
    vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
        vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
    return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress(
    VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_2) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddress", "VK_VERSION_1_2");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddress");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    uint64_t vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return = (uint64_t)0;
    vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return =
        vkEnc->vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo, true /* do lock */);
    return vkGetDeviceMemoryOpaqueCaptureAddress_uint64_t_return;
}
#endif
#ifdef VK_VERSION_1_3
static VkResult entry_vkGetPhysicalDeviceToolProperties(
    VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
    VkPhysicalDeviceToolProperties* pToolProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolProperties");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPhysicalDeviceToolProperties_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceToolProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceToolProperties(
        physicalDevice, pToolCount, pToolProperties, true /* do lock */);
    return vkGetPhysicalDeviceToolProperties_VkResult_return;
}
static VkResult entry_vkCreatePrivateDataSlot(VkDevice device,
                                              const VkPrivateDataSlotCreateInfo* pCreateInfo,
                                              const VkAllocationCallbacks* pAllocator,
                                              VkPrivateDataSlot* pPrivateDataSlot) {
    AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
    vkCreatePrivateDataSlot_VkResult_return = vkEnc->vkCreatePrivateDataSlot(
        device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
    return vkCreatePrivateDataSlot_VkResult_return;
}
static VkResult dynCheck_entry_vkCreatePrivateDataSlot(
    VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
        sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlot", "VK_VERSION_1_3");
    }
    AEMU_SCOPED_TRACE("vkCreatePrivateDataSlot");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
    vkCreatePrivateDataSlot_VkResult_return = vkEnc->vkCreatePrivateDataSlot(
        device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
    return vkCreatePrivateDataSlot_VkResult_return;
}
static void entry_vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot,
                                           const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator, true /* do lock */);
}
static void dynCheck_entry_vkDestroyPrivateDataSlot(VkDevice device,
                                                    VkPrivateDataSlot privateDataSlot,
                                                    const VkAllocationCallbacks* pAllocator) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
        sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlot", "VK_VERSION_1_3");
    }
    AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlot");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator, true /* do lock */);
}
static VkResult entry_vkSetPrivateData(VkDevice device, VkObjectType objectType,
                                       uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
                                       uint64_t data) {
    AEMU_SCOPED_TRACE("vkSetPrivateData");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
    vkSetPrivateData_VkResult_return = vkEnc->vkSetPrivateData(
        device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
    return vkSetPrivateData_VkResult_return;
}
static VkResult dynCheck_entry_vkSetPrivateData(VkDevice device, VkObjectType objectType,
                                                uint64_t objectHandle,
                                                VkPrivateDataSlot privateDataSlot, uint64_t data) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
        sOnInvalidDynamicallyCheckedCall("vkSetPrivateData", "VK_VERSION_1_3");
    }
    AEMU_SCOPED_TRACE("vkSetPrivateData");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
    vkSetPrivateData_VkResult_return = vkEnc->vkSetPrivateData(
        device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
    return vkSetPrivateData_VkResult_return;
}
static void entry_vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle,
                                   VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
    AEMU_SCOPED_TRACE("vkGetPrivateData");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData,
                            true /* do lock */);
}
static void dynCheck_entry_vkGetPrivateData(VkDevice device, VkObjectType objectType,
                                            uint64_t objectHandle,
                                            VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
        sOnInvalidDynamicallyCheckedCall("vkGetPrivateData", "VK_VERSION_1_3");
    }
    AEMU_SCOPED_TRACE("vkGetPrivateData");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData,
                            true /* do lock */);
}
static void entry_vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
                                 const VkDependencyInfo* pDependencyInfo) {
    AEMU_SCOPED_TRACE("vkCmdSetEvent2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetEvent2(commandBuffer, event, pDependencyInfo, true /* do lock */);
}
static void entry_vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event,
                                   VkPipelineStageFlags2 stageMask) {
    AEMU_SCOPED_TRACE("vkCmdResetEvent2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResetEvent2(commandBuffer, event, stageMask, true /* do lock */);
}
static void entry_vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount,
                                   const VkEvent* pEvents,
                                   const VkDependencyInfo* pDependencyInfos) {
    AEMU_SCOPED_TRACE("vkCmdWaitEvents2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos,
                            true /* do lock */);
}
static void entry_vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer,
                                        const VkDependencyInfo* pDependencyInfo) {
    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo, true /* do lock */);
}
static void entry_vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage,
                                       VkQueryPool queryPool, uint32_t query) {
    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query, true /* do lock */);
}
static VkResult entry_vkQueueSubmit2(VkQueue queue, uint32_t submitCount,
                                     const VkSubmitInfo2* pSubmits, VkFence fence) {
    AEMU_SCOPED_TRACE("vkQueueSubmit2");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    VkResult vkQueueSubmit2_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkQueueSubmit2_VkResult_return =
        resources->on_vkQueueSubmit2(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
    return vkQueueSubmit2_VkResult_return;
}
static void entry_vkCmdCopyBuffer2(VkCommandBuffer commandBuffer,
                                   const VkCopyBufferInfo2* pCopyBufferInfo) {
    AEMU_SCOPED_TRACE("vkCmdCopyBuffer2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo, true /* do lock */);
}
static void entry_vkCmdCopyImage2(VkCommandBuffer commandBuffer,
                                  const VkCopyImageInfo2* pCopyImageInfo) {
    AEMU_SCOPED_TRACE("vkCmdCopyImage2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyImage2(commandBuffer, pCopyImageInfo, true /* do lock */);
}
static void entry_vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer,
                                          const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
}
static void entry_vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer,
                                          const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
}
static void entry_vkCmdBlitImage2(VkCommandBuffer commandBuffer,
                                  const VkBlitImageInfo2* pBlitImageInfo) {
    AEMU_SCOPED_TRACE("vkCmdBlitImage2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBlitImage2(commandBuffer, pBlitImageInfo, true /* do lock */);
}
static void entry_vkCmdResolveImage2(VkCommandBuffer commandBuffer,
                                     const VkResolveImageInfo2* pResolveImageInfo) {
    AEMU_SCOPED_TRACE("vkCmdResolveImage2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResolveImage2(commandBuffer, pResolveImageInfo, true /* do lock */);
}
static void entry_vkCmdBeginRendering(VkCommandBuffer commandBuffer,
                                      const VkRenderingInfo* pRenderingInfo) {
    AEMU_SCOPED_TRACE("vkCmdBeginRendering");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginRendering(commandBuffer, pRenderingInfo, true /* do lock */);
}
static void entry_vkCmdEndRendering(VkCommandBuffer commandBuffer) {
    AEMU_SCOPED_TRACE("vkCmdEndRendering");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndRendering(commandBuffer, true /* do lock */);
}
static void entry_vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
    AEMU_SCOPED_TRACE("vkCmdSetCullMode");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetCullMode(commandBuffer, cullMode, true /* do lock */);
}
static void entry_vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
    AEMU_SCOPED_TRACE("vkCmdSetFrontFace");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetFrontFace(commandBuffer, frontFace, true /* do lock */);
}
static void entry_vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer,
                                            VkPrimitiveTopology primitiveTopology) {
    AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopology");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology, true /* do lock */);
}
static void entry_vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount,
                                            const VkViewport* pViewports) {
    AEMU_SCOPED_TRACE("vkCmdSetViewportWithCount");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports, true /* do lock */);
}
static void entry_vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount,
                                           const VkRect2D* pScissors) {
    AEMU_SCOPED_TRACE("vkCmdSetScissorWithCount");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors, true /* do lock */);
}
static void entry_vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding,
                                          uint32_t bindingCount, const VkBuffer* pBuffers,
                                          const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
                                          const VkDeviceSize* pStrides) {
    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
                                   pSizes, pStrides, true /* do lock */);
}
static void entry_vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnable");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable, true /* do lock */);
}
static void entry_vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer,
                                           VkBool32 depthWriteEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnable");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable, true /* do lock */);
}
static void entry_vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer,
                                         VkCompareOp depthCompareOp) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOp");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp, true /* do lock */);
}
static void entry_vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer,
                                                VkBool32 depthBoundsTestEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnable");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable, true /* do lock */);
}
static void entry_vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer,
                                            VkBool32 stencilTestEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnable");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable, true /* do lock */);
}
static void entry_vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
                                    VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp,
                                    VkCompareOp compareOp) {
    AEMU_SCOPED_TRACE("vkCmdSetStencilOp");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
                             true /* do lock */);
}
static void entry_vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer,
                                                  VkBool32 rasterizerDiscardEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnable");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable,
                                           true /* do lock */);
}
static void entry_vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnable");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable, true /* do lock */);
}
static void entry_vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer,
                                                 VkBool32 primitiveRestartEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnable");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable,
                                          true /* do lock */);
}
static void entry_vkGetDeviceBufferMemoryRequirements(VkDevice device,
                                                      const VkDeviceBufferMemoryRequirements* pInfo,
                                                      VkMemoryRequirements2* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements,
                                               true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceBufferMemoryRequirements(
    VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirements", "VK_VERSION_1_3");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements,
                                               true /* do lock */);
}
static void entry_vkGetDeviceImageMemoryRequirements(VkDevice device,
                                                     const VkDeviceImageMemoryRequirements* pInfo,
                                                     VkMemoryRequirements2* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements,
                                              true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceImageMemoryRequirements(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirements", "VK_VERSION_1_3");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements,
                                              true /* do lock */);
}
static void entry_vkGetDeviceImageSparseMemoryRequirements(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount,
                                                    pSparseMemoryRequirements, true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirements(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_3) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirements",
                                         "VK_VERSION_1_3");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirements");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount,
                                                    pSparseMemoryRequirements, true /* do lock */);
}
#endif
#ifdef VK_KHR_surface
#endif
#ifdef VK_KHR_swapchain
static VkResult entry_vkCreateSwapchainKHR(VkDevice device,
                                           const VkSwapchainCreateInfoKHR* pCreateInfo,
                                           const VkAllocationCallbacks* pAllocator,
                                           VkSwapchainKHR* pSwapchain) {
    AEMU_SCOPED_TRACE("vkCreateSwapchainKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
    vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(
        device, pCreateInfo, pAllocator, pSwapchain, true /* do lock */);
    return vkCreateSwapchainKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSwapchainKHR(VkDevice device,
                                                    const VkSwapchainCreateInfoKHR* pCreateInfo,
                                                    const VkAllocationCallbacks* pAllocator,
                                                    VkSwapchainKHR* pSwapchain) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
        sOnInvalidDynamicallyCheckedCall("vkCreateSwapchainKHR", "VK_KHR_swapchain");
    }
    AEMU_SCOPED_TRACE("vkCreateSwapchainKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
    vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(
        device, pCreateInfo, pAllocator, pSwapchain, true /* do lock */);
    return vkCreateSwapchainKHR_VkResult_return;
}
static void entry_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
                                        const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroySwapchainKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator, true /* do lock */);
}
static void dynCheck_entry_vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
                                                 const VkAllocationCallbacks* pAllocator) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
        sOnInvalidDynamicallyCheckedCall("vkDestroySwapchainKHR", "VK_KHR_swapchain");
    }
    AEMU_SCOPED_TRACE("vkDestroySwapchainKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator, true /* do lock */);
}
static VkResult entry_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
                                              uint32_t* pSwapchainImageCount,
                                              VkImage* pSwapchainImages) {
    AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
    vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(
        device, swapchain, pSwapchainImageCount, pSwapchainImages, true /* do lock */);
    return vkGetSwapchainImagesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain,
                                                       uint32_t* pSwapchainImageCount,
                                                       VkImage* pSwapchainImages) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
        sOnInvalidDynamicallyCheckedCall("vkGetSwapchainImagesKHR", "VK_KHR_swapchain");
    }
    AEMU_SCOPED_TRACE("vkGetSwapchainImagesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
    vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(
        device, swapchain, pSwapchainImageCount, pSwapchainImages, true /* do lock */);
    return vkGetSwapchainImagesKHR_VkResult_return;
}
static VkResult entry_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain,
                                            uint64_t timeout, VkSemaphore semaphore, VkFence fence,
                                            uint32_t* pImageIndex) {
    AEMU_SCOPED_TRACE("vkAcquireNextImageKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
    vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(
        device, swapchain, timeout, semaphore, fence, pImageIndex, true /* do lock */);
    return vkAcquireNextImageKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain,
                                                     uint64_t timeout, VkSemaphore semaphore,
                                                     VkFence fence, uint32_t* pImageIndex) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
        sOnInvalidDynamicallyCheckedCall("vkAcquireNextImageKHR", "VK_KHR_swapchain");
    }
    AEMU_SCOPED_TRACE("vkAcquireNextImageKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
    vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(
        device, swapchain, timeout, semaphore, fence, pImageIndex, true /* do lock */);
    return vkAcquireNextImageKHR_VkResult_return;
}
static VkResult entry_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) {
    AEMU_SCOPED_TRACE("vkQueuePresentKHR");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
    vkQueuePresentKHR_VkResult_return =
        vkEnc->vkQueuePresentKHR(queue, pPresentInfo, true /* do lock */);
    return vkQueuePresentKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR(
    VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
    AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
    vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return =
        vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities,
                                                      true /* do lock */);
    return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetDeviceGroupPresentCapabilitiesKHR(
    VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPresentCapabilitiesKHR",
                                         "VK_KHR_swapchain");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceGroupPresentCapabilitiesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
    vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return =
        vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities,
                                                      true /* do lock */);
    return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR(
    VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
    AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
    vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return =
        vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, true /* do lock */);
    return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetDeviceGroupSurfacePresentModesKHR(
    VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupSurfacePresentModesKHR",
                                         "VK_KHR_swapchain");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceGroupSurfacePresentModesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
    vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return =
        vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes, true /* do lock */);
    return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice,
                                                              VkSurfaceKHR surface,
                                                              uint32_t* pRectCount,
                                                              VkRect2D* pRects) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
    vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return =
        vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects,
                                                       true /* do lock */);
    return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
}
static VkResult entry_vkAcquireNextImage2KHR(VkDevice device,
                                             const VkAcquireNextImageInfoKHR* pAcquireInfo,
                                             uint32_t* pImageIndex) {
    AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
    vkAcquireNextImage2KHR_VkResult_return =
        vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, true /* do lock */);
    return vkAcquireNextImage2KHR_VkResult_return;
}
static VkResult dynCheck_entry_vkAcquireNextImage2KHR(VkDevice device,
                                                      const VkAcquireNextImageInfoKHR* pAcquireInfo,
                                                      uint32_t* pImageIndex) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_swapchain")) {
        sOnInvalidDynamicallyCheckedCall("vkAcquireNextImage2KHR", "VK_KHR_swapchain");
    }
    AEMU_SCOPED_TRACE("vkAcquireNextImage2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
    vkAcquireNextImage2KHR_VkResult_return =
        vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex, true /* do lock */);
    return vkAcquireNextImage2KHR_VkResult_return;
}
#endif
#ifdef VK_KHR_xcb_surface
#endif
#ifdef VK_KHR_android_surface
static VkResult entry_vkCreateAndroidSurfaceKHR(VkInstance instance,
                                                const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
                                                const VkAllocationCallbacks* pAllocator,
                                                VkSurfaceKHR* pSurface) {
    AEMU_SCOPED_TRACE("vkCreateAndroidSurfaceKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateAndroidSurfaceKHR_VkResult_return = (VkResult)0;
    vkCreateAndroidSurfaceKHR_VkResult_return = vkEnc->vkCreateAndroidSurfaceKHR(
        instance, pCreateInfo, pAllocator, pSurface, true /* do lock */);
    return vkCreateAndroidSurfaceKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_win32_surface
#endif
#ifdef VK_KHR_dynamic_rendering
static void entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
                                         const VkRenderingInfo* pRenderingInfo) {
    AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdBeginRenderingKHR(VkCommandBuffer commandBuffer,
                                                  const VkRenderingInfo* pRenderingInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderingKHR", "VK_KHR_dynamic_rendering");
    }
    AEMU_SCOPED_TRACE("vkCmdBeginRenderingKHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo, true /* do lock */);
}
static void entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
    AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
}
static void dynCheck_entry_vkCmdEndRenderingKHR(VkCommandBuffer commandBuffer) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderingKHR", "VK_KHR_dynamic_rendering");
    }
    AEMU_SCOPED_TRACE("vkCmdEndRenderingKHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndRenderingKHR(commandBuffer, true /* do lock */);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
static void entry_vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice,
                                                  VkPhysicalDeviceFeatures2* pFeatures) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice,
                                                    VkPhysicalDeviceProperties2* pProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice,
                                                          VkFormat format,
                                                          VkFormatProperties2* pFormatProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties,
                                                   true /* do lock */);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2KHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return =
        resources->on_vkGetPhysicalDeviceImageFormatProperties2KHR(
            vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
    return vkGetPhysicalDeviceImageFormatProperties2KHR_VkResult_return;
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR(
    VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount,
                                                        pQueueFamilyProperties, true /* do lock */);
}
static void entry_vkGetPhysicalDeviceMemoryProperties2KHR(
    VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties,
                                                   true /* do lock */);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
        physicalDevice, pFormatInfo, pPropertyCount, pProperties, true /* do lock */);
}
#endif
#ifdef VK_KHR_maintenance1
static void entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
                                       VkCommandPoolTrimFlags flags) {
    AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
}
static void dynCheck_entry_vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool,
                                                VkCommandPoolTrimFlags flags) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance1")) {
        sOnInvalidDynamicallyCheckedCall("vkTrimCommandPoolKHR", "VK_KHR_maintenance1");
    }
    AEMU_SCOPED_TRACE("vkTrimCommandPoolKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_memory_capabilities
static void entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferPropertiesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetPhysicalDeviceExternalBufferPropertiesKHR(
        vkEnc, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
#endif
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
#endif
#ifdef VK_KHR_external_memory_fd
#endif
#ifdef VK_KHR_external_semaphore_capabilities
static void entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
        physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
#endif
#ifdef VK_KHR_external_semaphore_fd
static VkResult entry_vkImportSemaphoreFdKHR(
    VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
    AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkImportSemaphoreFdKHR_VkResult_return =
        resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
    return vkImportSemaphoreFdKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkImportSemaphoreFdKHR(
    VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
        sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
    }
    AEMU_SCOPED_TRACE("vkImportSemaphoreFdKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkImportSemaphoreFdKHR_VkResult_return = (VkResult)0;
    vkImportSemaphoreFdKHR_VkResult_return =
        resources->on_vkImportSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pImportSemaphoreFdInfo);
    return vkImportSemaphoreFdKHR_VkResult_return;
}
static VkResult entry_vkGetSemaphoreFdKHR(VkDevice device,
                                          const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) {
    AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkGetSemaphoreFdKHR_VkResult_return =
        resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
    return vkGetSemaphoreFdKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSemaphoreFdKHR(VkDevice device,
                                                   const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
                                                   int* pFd) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd")) {
        sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreFdKHR", "VK_KHR_external_semaphore_fd");
    }
    AEMU_SCOPED_TRACE("vkGetSemaphoreFdKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSemaphoreFdKHR_VkResult_return = (VkResult)0;
    vkGetSemaphoreFdKHR_VkResult_return =
        resources->on_vkGetSemaphoreFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
    return vkGetSemaphoreFdKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_shader_float16_int8
#endif
#ifdef VK_KHR_incremental_present
#endif
#ifdef VK_KHR_descriptor_update_template
static VkResult entry_vkCreateDescriptorUpdateTemplateKHR(
    VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
    vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
        vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
                                                   pDescriptorUpdateTemplate, true /* do lock */);
    return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR(
    VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
        sOnInvalidDynamicallyCheckedCall("vkCreateDescriptorUpdateTemplateKHR",
                                         "VK_KHR_descriptor_update_template");
    }
    AEMU_SCOPED_TRACE("vkCreateDescriptorUpdateTemplateKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
    vkCreateDescriptorUpdateTemplateKHR_VkResult_return =
        vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator,
                                                   pDescriptorUpdateTemplate, true /* do lock */);
    return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
}
static void entry_vkDestroyDescriptorUpdateTemplateKHR(
    VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
                                                true /* do lock */);
}
static void dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR(
    VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
        sOnInvalidDynamicallyCheckedCall("vkDestroyDescriptorUpdateTemplateKHR",
                                         "VK_KHR_descriptor_update_template");
    }
    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplateKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator,
                                                true /* do lock */);
}
static void entry_vkUpdateDescriptorSetWithTemplateKHR(
    VkDevice device, VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
                                                pData, true /* do lock */);
}
static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR(
    VkDevice device, VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template")) {
        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateKHR",
                                         "VK_KHR_descriptor_update_template");
    }
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate,
                                                pData, true /* do lock */);
}
#endif
#ifdef VK_KHR_imageless_framebuffer
#endif
#ifdef VK_KHR_create_renderpass2
static VkResult entry_vkCreateRenderPass2KHR(VkDevice device,
                                             const VkRenderPassCreateInfo2* pCreateInfo,
                                             const VkAllocationCallbacks* pAllocator,
                                             VkRenderPass* pRenderPass) {
    AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
    vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
        device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
    return vkCreateRenderPass2KHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateRenderPass2KHR(VkDevice device,
                                                      const VkRenderPassCreateInfo2* pCreateInfo,
                                                      const VkAllocationCallbacks* pAllocator,
                                                      VkRenderPass* pRenderPass) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
        sOnInvalidDynamicallyCheckedCall("vkCreateRenderPass2KHR", "VK_KHR_create_renderpass2");
    }
    AEMU_SCOPED_TRACE("vkCreateRenderPass2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
    vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(
        device, pCreateInfo, pAllocator, pRenderPass, true /* do lock */);
    return vkCreateRenderPass2KHR_VkResult_return;
}
static void entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
                                           const VkRenderPassBeginInfo* pRenderPassBegin,
                                           const VkSubpassBeginInfo* pSubpassBeginInfo) {
    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
                                    true /* do lock */);
}
static void dynCheck_entry_vkCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
                                                    const VkRenderPassBeginInfo* pRenderPassBegin,
                                                    const VkSubpassBeginInfo* pSubpassBeginInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdBeginRenderPass2KHR", "VK_KHR_create_renderpass2");
    }
    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo,
                                    true /* do lock */);
}
static void entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
                                       const VkSubpassBeginInfo* pSubpassBeginInfo,
                                       const VkSubpassEndInfo* pSubpassEndInfo) {
    AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
                                true /* do lock */);
}
static void dynCheck_entry_vkCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
                                                const VkSubpassBeginInfo* pSubpassBeginInfo,
                                                const VkSubpassEndInfo* pSubpassEndInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdNextSubpass2KHR", "VK_KHR_create_renderpass2");
    }
    AEMU_SCOPED_TRACE("vkCmdNextSubpass2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo,
                                true /* do lock */);
}
static void entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
                                         const VkSubpassEndInfo* pSubpassEndInfo) {
    AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
                                                  const VkSubpassEndInfo* pSubpassEndInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdEndRenderPass2KHR", "VK_KHR_create_renderpass2");
    }
    AEMU_SCOPED_TRACE("vkCmdEndRenderPass2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo, true /* do lock */);
}
#endif
#ifdef VK_KHR_external_fence_capabilities
static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFencePropertiesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetPhysicalDeviceExternalFencePropertiesKHR(
        vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_fd
static VkResult entry_vkImportFenceFdKHR(VkDevice device,
                                         const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
    AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkImportFenceFdKHR_VkResult_return =
        resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
    return vkImportFenceFdKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkImportFenceFdKHR(
    VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
        sOnInvalidDynamicallyCheckedCall("vkImportFenceFdKHR", "VK_KHR_external_fence_fd");
    }
    AEMU_SCOPED_TRACE("vkImportFenceFdKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkImportFenceFdKHR_VkResult_return = (VkResult)0;
    vkImportFenceFdKHR_VkResult_return =
        resources->on_vkImportFenceFdKHR(vkEnc, VK_SUCCESS, device, pImportFenceFdInfo);
    return vkImportFenceFdKHR_VkResult_return;
}
static VkResult entry_vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo,
                                      int* pFd) {
    AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkGetFenceFdKHR_VkResult_return =
        resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
    return vkGetFenceFdKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetFenceFdKHR(VkDevice device,
                                               const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd")) {
        sOnInvalidDynamicallyCheckedCall("vkGetFenceFdKHR", "VK_KHR_external_fence_fd");
    }
    AEMU_SCOPED_TRACE("vkGetFenceFdKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetFenceFdKHR_VkResult_return = (VkResult)0;
    vkGetFenceFdKHR_VkResult_return =
        resources->on_vkGetFenceFdKHR(vkEnc, VK_SUCCESS, device, pGetFdInfo, pFd);
    return vkGetFenceFdKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_dedicated_allocation
#endif
#ifdef VK_KHR_storage_buffer_storage_class
#endif
#ifdef VK_KHR_get_memory_requirements2
static void entry_vkGetImageMemoryRequirements2KHR(VkDevice device,
                                                   const VkImageMemoryRequirementsInfo2* pInfo,
                                                   VkMemoryRequirements2* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetImageMemoryRequirements2KHR(
    VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
        sOnInvalidDynamicallyCheckedCall("vkGetImageMemoryRequirements2KHR",
                                         "VK_KHR_get_memory_requirements2");
    }
    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetBufferMemoryRequirements2KHR(VkDevice device,
                                                    const VkBufferMemoryRequirementsInfo2* pInfo,
                                                    VkMemoryRequirements2* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
static void dynCheck_entry_vkGetBufferMemoryRequirements2KHR(
    VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
        sOnInvalidDynamicallyCheckedCall("vkGetBufferMemoryRequirements2KHR",
                                         "VK_KHR_get_memory_requirements2");
    }
    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements2KHR(
    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
                                                  pSparseMemoryRequirements, true /* do lock */);
}
static void dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR(
    VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2")) {
        sOnInvalidDynamicallyCheckedCall("vkGetImageSparseMemoryRequirements2KHR",
                                         "VK_KHR_get_memory_requirements2");
    }
    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount,
                                                  pSparseMemoryRequirements, true /* do lock */);
}
#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
static VkResult entry_vkCreateSamplerYcbcrConversionKHR(
    VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateSamplerYcbcrConversionKHR_VkResult_return =
        resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
                                                        pAllocator, pYcbcrConversion);
    return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversionKHR(
    VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
        sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversionKHR",
                                         "VK_KHR_sampler_ycbcr_conversion");
    }
    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversionKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateSamplerYcbcrConversionKHR_VkResult_return = (VkResult)0;
    vkCreateSamplerYcbcrConversionKHR_VkResult_return =
        resources->on_vkCreateSamplerYcbcrConversionKHR(vkEnc, VK_SUCCESS, device, pCreateInfo,
                                                        pAllocator, pYcbcrConversion);
    return vkCreateSamplerYcbcrConversionKHR_VkResult_return;
}
static void entry_vkDestroySamplerYcbcrConversionKHR(VkDevice device,
                                                     VkSamplerYcbcrConversion ycbcrConversion,
                                                     const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
}
static void dynCheck_entry_vkDestroySamplerYcbcrConversionKHR(
    VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion")) {
        sOnInvalidDynamicallyCheckedCall("vkDestroySamplerYcbcrConversionKHR",
                                         "VK_KHR_sampler_ycbcr_conversion");
    }
    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversionKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
}
#endif
#ifdef VK_KHR_bind_memory2
static VkResult entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
                                             const VkBindBufferMemoryInfo* pBindInfos) {
    AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindBufferMemory2KHR_VkResult_return =
        resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindBufferMemory2KHR_VkResult_return;
}
static VkResult dynCheck_entry_vkBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
                                                      const VkBindBufferMemoryInfo* pBindInfos) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
        sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2KHR", "VK_KHR_bind_memory2");
    }
    AEMU_SCOPED_TRACE("vkBindBufferMemory2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindBufferMemory2KHR_VkResult_return = (VkResult)0;
    vkBindBufferMemory2KHR_VkResult_return =
        resources->on_vkBindBufferMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindBufferMemory2KHR_VkResult_return;
}
static VkResult entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
                                            const VkBindImageMemoryInfo* pBindInfos) {
    AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindImageMemory2KHR_VkResult_return =
        resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindImageMemory2KHR_VkResult_return;
}
static VkResult dynCheck_entry_vkBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
                                                     const VkBindImageMemoryInfo* pBindInfos) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_bind_memory2")) {
        sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2KHR", "VK_KHR_bind_memory2");
    }
    AEMU_SCOPED_TRACE("vkBindImageMemory2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkBindImageMemory2KHR_VkResult_return = (VkResult)0;
    vkBindImageMemory2KHR_VkResult_return =
        resources->on_vkBindImageMemory2KHR(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindImageMemory2KHR_VkResult_return;
}
#endif
#ifdef VK_KHR_maintenance3
static void entry_vkGetDescriptorSetLayoutSupportKHR(
    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport) {
    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
}
static void dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR(
    VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance3")) {
        sOnInvalidDynamicallyCheckedCall("vkGetDescriptorSetLayoutSupportKHR",
                                         "VK_KHR_maintenance3");
    }
    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupportKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport, true /* do lock */);
}
#endif
#ifdef VK_KHR_shader_subgroup_extended_types
#endif
#ifdef VK_KHR_vulkan_memory_model
#endif
#ifdef VK_KHR_shader_terminate_invocation
#endif
#ifdef VK_KHR_buffer_device_address
static VkDeviceAddress entry_vkGetBufferDeviceAddressKHR(VkDevice device,
                                                         const VkBufferDeviceAddressInfo* pInfo) {
    AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
    vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
        vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
    return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
}
static VkDeviceAddress dynCheck_entry_vkGetBufferDeviceAddressKHR(
    VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
        sOnInvalidDynamicallyCheckedCall("vkGetBufferDeviceAddressKHR",
                                         "VK_KHR_buffer_device_address");
    }
    AEMU_SCOPED_TRACE("vkGetBufferDeviceAddressKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkDeviceAddress vkGetBufferDeviceAddressKHR_VkDeviceAddress_return = (VkDeviceAddress)0;
    vkGetBufferDeviceAddressKHR_VkDeviceAddress_return =
        vkEnc->vkGetBufferDeviceAddressKHR(device, pInfo, true /* do lock */);
    return vkGetBufferDeviceAddressKHR_VkDeviceAddress_return;
}
static uint64_t entry_vkGetBufferOpaqueCaptureAddressKHR(VkDevice device,
                                                         const VkBufferDeviceAddressInfo* pInfo) {
    AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
    vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
        vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
    return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR(
    VkDevice device, const VkBufferDeviceAddressInfo* pInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
        sOnInvalidDynamicallyCheckedCall("vkGetBufferOpaqueCaptureAddressKHR",
                                         "VK_KHR_buffer_device_address");
    }
    AEMU_SCOPED_TRACE("vkGetBufferOpaqueCaptureAddressKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    uint64_t vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
    vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return =
        vkEnc->vkGetBufferOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
    return vkGetBufferOpaqueCaptureAddressKHR_uint64_t_return;
}
static uint64_t entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
    VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
    AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
    vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
        vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
    return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
}
static uint64_t dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR(
    VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address")) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceMemoryOpaqueCaptureAddressKHR",
                                         "VK_KHR_buffer_device_address");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceMemoryOpaqueCaptureAddressKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return = (uint64_t)0;
    vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return =
        vkEnc->vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo, true /* do lock */);
    return vkGetDeviceMemoryOpaqueCaptureAddressKHR_uint64_t_return;
}
#endif
#ifdef VK_KHR_pipeline_executable_properties
static VkResult entry_vkGetPipelineExecutablePropertiesKHR(
    VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
    VkPipelineExecutablePropertiesKHR* pProperties) {
    AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
    vkGetPipelineExecutablePropertiesKHR_VkResult_return =
        vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
                                                    pProperties, true /* do lock */);
    return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetPipelineExecutablePropertiesKHR(
    VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount,
    VkPipelineExecutablePropertiesKHR* pProperties) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
        sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutablePropertiesKHR",
                                         "VK_KHR_pipeline_executable_properties");
    }
    AEMU_SCOPED_TRACE("vkGetPipelineExecutablePropertiesKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPipelineExecutablePropertiesKHR_VkResult_return = (VkResult)0;
    vkGetPipelineExecutablePropertiesKHR_VkResult_return =
        vkEnc->vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount,
                                                    pProperties, true /* do lock */);
    return vkGetPipelineExecutablePropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetPipelineExecutableStatisticsKHR(
    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
    VkPipelineExecutableStatisticKHR* pStatistics) {
    AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
    vkGetPipelineExecutableStatisticsKHR_VkResult_return =
        vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
                                                    pStatistics, true /* do lock */);
    return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetPipelineExecutableStatisticsKHR(
    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount,
    VkPipelineExecutableStatisticKHR* pStatistics) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
        sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableStatisticsKHR",
                                         "VK_KHR_pipeline_executable_properties");
    }
    AEMU_SCOPED_TRACE("vkGetPipelineExecutableStatisticsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPipelineExecutableStatisticsKHR_VkResult_return = (VkResult)0;
    vkGetPipelineExecutableStatisticsKHR_VkResult_return =
        vkEnc->vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount,
                                                    pStatistics, true /* do lock */);
    return vkGetPipelineExecutableStatisticsKHR_VkResult_return;
}
static VkResult entry_vkGetPipelineExecutableInternalRepresentationsKHR(
    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
    uint32_t* pInternalRepresentationCount,
    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
    AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
    vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
        vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
            device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
            true /* do lock */);
    return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
}
static VkResult dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR(
    VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
    uint32_t* pInternalRepresentationCount,
    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties")) {
        sOnInvalidDynamicallyCheckedCall("vkGetPipelineExecutableInternalRepresentationsKHR",
                                         "VK_KHR_pipeline_executable_properties");
    }
    AEMU_SCOPED_TRACE("vkGetPipelineExecutableInternalRepresentationsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return = (VkResult)0;
    vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return =
        vkEnc->vkGetPipelineExecutableInternalRepresentationsKHR(
            device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations,
            true /* do lock */);
    return vkGetPipelineExecutableInternalRepresentationsKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_shader_integer_dot_product
#endif
#ifdef VK_KHR_shader_non_semantic_info
#endif
#ifdef VK_KHR_synchronization2
static void entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
                                    const VkDependencyInfo* pDependencyInfo) {
    AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
                                             const VkDependencyInfo* pDependencyInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetEvent2KHR", "VK_KHR_synchronization2");
    }
    AEMU_SCOPED_TRACE("vkCmdSetEvent2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo, true /* do lock */);
}
static void entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
                                      VkPipelineStageFlags2 stageMask) {
    AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
}
static void dynCheck_entry_vkCmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event,
                                               VkPipelineStageFlags2 stageMask) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdResetEvent2KHR", "VK_KHR_synchronization2");
    }
    AEMU_SCOPED_TRACE("vkCmdResetEvent2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResetEvent2KHR(commandBuffer, event, stageMask, true /* do lock */);
}
static void entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
                                      const VkEvent* pEvents,
                                      const VkDependencyInfo* pDependencyInfos) {
    AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
                               true /* do lock */);
}
static void dynCheck_entry_vkCmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount,
                                               const VkEvent* pEvents,
                                               const VkDependencyInfo* pDependencyInfos) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdWaitEvents2KHR", "VK_KHR_synchronization2");
    }
    AEMU_SCOPED_TRACE("vkCmdWaitEvents2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos,
                               true /* do lock */);
}
static void entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
                                           const VkDependencyInfo* pDependencyInfo) {
    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer,
                                                    const VkDependencyInfo* pDependencyInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdPipelineBarrier2KHR", "VK_KHR_synchronization2");
    }
    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo, true /* do lock */);
}
static void entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
                                          VkPipelineStageFlags2 stage, VkQueryPool queryPool,
                                          uint32_t query) {
    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
}
static void dynCheck_entry_vkCmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer,
                                                   VkPipelineStageFlags2 stage,
                                                   VkQueryPool queryPool, uint32_t query) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdWriteTimestamp2KHR", "VK_KHR_synchronization2");
    }
    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query, true /* do lock */);
}
static VkResult entry_vkQueueSubmit2KHR(VkQueue queue, uint32_t submitCount,
                                        const VkSubmitInfo2* pSubmits, VkFence fence) {
    AEMU_SCOPED_TRACE("vkQueueSubmit2KHR");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    VkResult vkQueueSubmit2KHR_VkResult_return = (VkResult)0;
    vkQueueSubmit2KHR_VkResult_return =
        vkEnc->vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence, true /* do lock */);
    return vkQueueSubmit2KHR_VkResult_return;
}
static void entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
                                             VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
                                             VkDeviceSize dstOffset, uint32_t marker) {
    AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
                                      true /* do lock */);
}
static void dynCheck_entry_vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer,
                                                      VkPipelineStageFlags2 stage,
                                                      VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                                      uint32_t marker) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_synchronization2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdWriteBufferMarker2AMD", "VK_KHR_synchronization2");
    }
    AEMU_SCOPED_TRACE("vkCmdWriteBufferMarker2AMD");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker,
                                      true /* do lock */);
}
static void entry_vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount,
                                              VkCheckpointData2NV* pCheckpointData) {
    AEMU_SCOPED_TRACE("vkGetQueueCheckpointData2NV");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData,
                                       true /* do lock */);
}
#endif
#ifdef VK_KHR_zero_initialize_workgroup_memory
#endif
#ifdef VK_KHR_copy_commands2
static void entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
                                      const VkCopyBufferInfo2* pCopyBufferInfo) {
    AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
                                               const VkCopyBufferInfo2* pCopyBufferInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdCopyBuffer2KHR", "VK_KHR_copy_commands2");
    }
    AEMU_SCOPED_TRACE("vkCmdCopyBuffer2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo, true /* do lock */);
}
static void entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
                                     const VkCopyImageInfo2* pCopyImageInfo) {
    AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
                                              const VkCopyImageInfo2* pCopyImageInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdCopyImage2KHR", "VK_KHR_copy_commands2");
    }
    AEMU_SCOPED_TRACE("vkCmdCopyImage2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo, true /* do lock */);
}
static void entry_vkCmdCopyBufferToImage2KHR(
    VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyBufferToImage2KHR(
    VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdCopyBufferToImage2KHR", "VK_KHR_copy_commands2");
    }
    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo, true /* do lock */);
}
static void entry_vkCmdCopyImageToBuffer2KHR(
    VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdCopyImageToBuffer2KHR(
    VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdCopyImageToBuffer2KHR", "VK_KHR_copy_commands2");
    }
    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo, true /* do lock */);
}
static void entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
                                     const VkBlitImageInfo2* pBlitImageInfo) {
    AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
                                              const VkBlitImageInfo2* pBlitImageInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdBlitImage2KHR", "VK_KHR_copy_commands2");
    }
    AEMU_SCOPED_TRACE("vkCmdBlitImage2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo, true /* do lock */);
}
static void entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
                                        const VkResolveImageInfo2* pResolveImageInfo) {
    AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
}
static void dynCheck_entry_vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
                                                 const VkResolveImageInfo2* pResolveImageInfo) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_copy_commands2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdResolveImage2KHR", "VK_KHR_copy_commands2");
    }
    AEMU_SCOPED_TRACE("vkCmdResolveImage2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo, true /* do lock */);
}
#endif
#ifdef VK_KHR_format_feature_flags2
#endif
#ifdef VK_KHR_maintenance4
static void entry_vkGetDeviceBufferMemoryRequirementsKHR(
    VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
                                                  true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR(
    VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceBufferMemoryRequirementsKHR",
                                         "VK_KHR_maintenance4");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceBufferMemoryRequirementsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
                                                  true /* do lock */);
}
static void entry_vkGetDeviceImageMemoryRequirementsKHR(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
                                                 true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
    VkMemoryRequirements2* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageMemoryRequirementsKHR",
                                         "VK_KHR_maintenance4");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceImageMemoryRequirementsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements,
                                                 true /* do lock */);
}
static void entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
                                                       pSparseMemoryRequirements,
                                                       true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR(
    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance4")) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSparseMemoryRequirementsKHR",
                                         "VK_KHR_maintenance4");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceImageSparseMemoryRequirementsKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount,
                                                       pSparseMemoryRequirements,
                                                       true /* do lock */);
}
#endif
#ifdef VK_KHR_maintenance5
static void entry_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                           VkDeviceSize offset, VkDeviceSize size,
                                           VkIndexType indexType) {
    AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType,
                                    true /* do lock */);
}
static void dynCheck_entry_vkCmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
                                                    VkDeviceSize offset, VkDeviceSize size,
                                                    VkIndexType indexType) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdBindIndexBuffer2KHR", "VK_KHR_maintenance5");
    }
    AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer2KHR");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType,
                                    true /* do lock */);
}
static void entry_vkGetRenderingAreaGranularityKHR(VkDevice device,
                                                   const VkRenderingAreaInfoKHR* pRenderingAreaInfo,
                                                   VkExtent2D* pGranularity) {
    AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity,
                                            true /* do lock */);
}
static void dynCheck_entry_vkGetRenderingAreaGranularityKHR(
    VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
        sOnInvalidDynamicallyCheckedCall("vkGetRenderingAreaGranularityKHR", "VK_KHR_maintenance5");
    }
    AEMU_SCOPED_TRACE("vkGetRenderingAreaGranularityKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity,
                                            true /* do lock */);
}
static void entry_vkGetDeviceImageSubresourceLayoutKHR(VkDevice device,
                                                       const VkDeviceImageSubresourceInfoKHR* pInfo,
                                                       VkSubresourceLayout2KHR* pLayout) {
    AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout, true /* do lock */);
}
static void dynCheck_entry_vkGetDeviceImageSubresourceLayoutKHR(
    VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo,
    VkSubresourceLayout2KHR* pLayout) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
        sOnInvalidDynamicallyCheckedCall("vkGetDeviceImageSubresourceLayoutKHR",
                                         "VK_KHR_maintenance5");
    }
    AEMU_SCOPED_TRACE("vkGetDeviceImageSubresourceLayoutKHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout, true /* do lock */);
}
static void entry_vkGetImageSubresourceLayout2KHR(VkDevice device, VkImage image,
                                                  const VkImageSubresource2KHR* pSubresource,
                                                  VkSubresourceLayout2KHR* pLayout) {
    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout,
                                           true /* do lock */);
}
static void dynCheck_entry_vkGetImageSubresourceLayout2KHR(
    VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource,
    VkSubresourceLayout2KHR* pLayout) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_KHR_maintenance5")) {
        sOnInvalidDynamicallyCheckedCall("vkGetImageSubresourceLayout2KHR", "VK_KHR_maintenance5");
    }
    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2KHR");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout,
                                           true /* do lock */);
}
#endif
#ifdef VK_ANDROID_native_buffer
static VkResult entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
                                                        VkImageUsageFlags imageUsage,
                                                        int* grallocUsage) {
    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
    vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
        device, format, imageUsage, grallocUsage, true /* do lock */);
    return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
                                                                 VkImageUsageFlags imageUsage,
                                                                 int* grallocUsage) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
        sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsageANDROID",
                                         "VK_ANDROID_native_buffer");
    }
    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsageANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
    vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(
        device, format, imageUsage, grallocUsage, true /* do lock */);
    return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
}
static VkResult entry_vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd,
                                            VkSemaphore semaphore, VkFence fence) {
    AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
    vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
        device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
    return vkAcquireImageANDROID_VkResult_return;
}
static VkResult dynCheck_entry_vkAcquireImageANDROID(VkDevice device, VkImage image,
                                                     int nativeFenceFd, VkSemaphore semaphore,
                                                     VkFence fence) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
        sOnInvalidDynamicallyCheckedCall("vkAcquireImageANDROID", "VK_ANDROID_native_buffer");
    }
    AEMU_SCOPED_TRACE("vkAcquireImageANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
    vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(
        device, image, nativeFenceFd, semaphore, fence, true /* do lock */);
    return vkAcquireImageANDROID_VkResult_return;
}
static VkResult entry_vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount,
                                                       const VkSemaphore* pWaitSemaphores,
                                                       VkImage image, int* pNativeFenceFd) {
    AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROID");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    VkResult vkQueueSignalReleaseImageANDROID_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkQueueSignalReleaseImageANDROID_VkResult_return =
        resources->on_vkQueueSignalReleaseImageANDROID(vkEnc, VK_SUCCESS, queue, waitSemaphoreCount,
                                                       pWaitSemaphores, image, pNativeFenceFd);
    return vkQueueSignalReleaseImageANDROID_VkResult_return;
}
static VkResult entry_vkGetSwapchainGrallocUsage2ANDROID(
    VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
    VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
    uint64_t* grallocProducerUsage) {
    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
    vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
        device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage,
        true /* do lock */);
    return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
}
static VkResult dynCheck_entry_vkGetSwapchainGrallocUsage2ANDROID(
    VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
    VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
    uint64_t* grallocProducerUsage) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer")) {
        sOnInvalidDynamicallyCheckedCall("vkGetSwapchainGrallocUsage2ANDROID",
                                         "VK_ANDROID_native_buffer");
    }
    AEMU_SCOPED_TRACE("vkGetSwapchainGrallocUsage2ANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
    vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsage2ANDROID(
        device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage,
        true /* do lock */);
    return vkGetSwapchainGrallocUsage2ANDROID_VkResult_return;
}
#endif
#ifdef VK_EXT_transform_feedback
static void entry_vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer,
                                                       uint32_t firstBinding, uint32_t bindingCount,
                                                       const VkBuffer* pBuffers,
                                                       const VkDeviceSize* pOffsets,
                                                       const VkDeviceSize* pSizes) {
    AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
                                                pOffsets, pSizes, true /* do lock */);
}
static void dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT(
    VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
    const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdBindTransformFeedbackBuffersEXT",
                                         "VK_EXT_transform_feedback");
    }
    AEMU_SCOPED_TRACE("vkCmdBindTransformFeedbackBuffersEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers,
                                                pOffsets, pSizes, true /* do lock */);
}
static void entry_vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer,
                                                 uint32_t firstCounterBuffer,
                                                 uint32_t counterBufferCount,
                                                 const VkBuffer* pCounterBuffers,
                                                 const VkDeviceSize* pCounterBufferOffsets) {
    AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
                                          pCounterBuffers, pCounterBufferOffsets,
                                          true /* do lock */);
}
static void dynCheck_entry_vkCmdBeginTransformFeedbackEXT(
    VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount,
    const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdBeginTransformFeedbackEXT",
                                         "VK_EXT_transform_feedback");
    }
    AEMU_SCOPED_TRACE("vkCmdBeginTransformFeedbackEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
                                          pCounterBuffers, pCounterBufferOffsets,
                                          true /* do lock */);
}
static void entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
                                               uint32_t firstCounterBuffer,
                                               uint32_t counterBufferCount,
                                               const VkBuffer* pCounterBuffers,
                                               const VkDeviceSize* pCounterBufferOffsets) {
    AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
                                        pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
}
static void dynCheck_entry_vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer,
                                                        uint32_t firstCounterBuffer,
                                                        uint32_t counterBufferCount,
                                                        const VkBuffer* pCounterBuffers,
                                                        const VkDeviceSize* pCounterBufferOffsets) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdEndTransformFeedbackEXT",
                                         "VK_EXT_transform_feedback");
    }
    AEMU_SCOPED_TRACE("vkCmdEndTransformFeedbackEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount,
                                        pCounterBuffers, pCounterBufferOffsets, true /* do lock */);
}
static void entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                            uint32_t query, VkQueryControlFlags flags,
                                            uint32_t index) {
    AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
                                     true /* do lock */);
}
static void dynCheck_entry_vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer,
                                                     VkQueryPool queryPool, uint32_t query,
                                                     VkQueryControlFlags flags, uint32_t index) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdBeginQueryIndexedEXT", "VK_EXT_transform_feedback");
    }
    AEMU_SCOPED_TRACE("vkCmdBeginQueryIndexedEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index,
                                     true /* do lock */);
}
static void entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
                                          uint32_t query, uint32_t index) {
    AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
}
static void dynCheck_entry_vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer,
                                                   VkQueryPool queryPool, uint32_t query,
                                                   uint32_t index) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdEndQueryIndexedEXT", "VK_EXT_transform_feedback");
    }
    AEMU_SCOPED_TRACE("vkCmdEndQueryIndexedEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index, true /* do lock */);
}
static void entry_vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
                                                uint32_t instanceCount, uint32_t firstInstance,
                                                VkBuffer counterBuffer,
                                                VkDeviceSize counterBufferOffset,
                                                uint32_t counterOffset, uint32_t vertexStride) {
    AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
                                         counterBufferOffset, counterOffset, vertexStride,
                                         true /* do lock */);
}
static void dynCheck_entry_vkCmdDrawIndirectByteCountEXT(
    VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance,
    VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset,
    uint32_t vertexStride) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_transform_feedback")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdDrawIndirectByteCountEXT",
                                         "VK_EXT_transform_feedback");
    }
    AEMU_SCOPED_TRACE("vkCmdDrawIndirectByteCountEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer,
                                         counterBufferOffset, counterOffset, vertexStride,
                                         true /* do lock */);
}
#endif
#ifdef VK_AMD_gpu_shader_half_float
#endif
#ifdef VK_EXT_texture_compression_astc_hdr
#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
static VkResult entry_vkGetAndroidHardwareBufferPropertiesANDROID(
    VkDevice device, const AHardwareBuffer* buffer,
    VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
    AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
        resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
                                                                  pProperties);
    return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
}
static VkResult dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID(
    VkDevice device, const AHardwareBuffer* buffer,
    VkAndroidHardwareBufferPropertiesANDROID* pProperties) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device,
                                       "VK_ANDROID_external_memory_android_hardware_buffer")) {
        sOnInvalidDynamicallyCheckedCall("vkGetAndroidHardwareBufferPropertiesANDROID",
                                         "VK_ANDROID_external_memory_android_hardware_buffer");
    }
    AEMU_SCOPED_TRACE("vkGetAndroidHardwareBufferPropertiesANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return = (VkResult)0;
    vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return =
        resources->on_vkGetAndroidHardwareBufferPropertiesANDROID(vkEnc, VK_SUCCESS, device, buffer,
                                                                  pProperties);
    return vkGetAndroidHardwareBufferPropertiesANDROID_VkResult_return;
}
static VkResult entry_vkGetMemoryAndroidHardwareBufferANDROID(
    VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    AHardwareBuffer** pBuffer) {
    AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
        resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
                                                              pBuffer);
    return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID(
    VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    AHardwareBuffer** pBuffer) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device,
                                       "VK_ANDROID_external_memory_android_hardware_buffer")) {
        sOnInvalidDynamicallyCheckedCall("vkGetMemoryAndroidHardwareBufferANDROID",
                                         "VK_ANDROID_external_memory_android_hardware_buffer");
    }
    AEMU_SCOPED_TRACE("vkGetMemoryAndroidHardwareBufferANDROID");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return = (VkResult)0;
    vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return =
        resources->on_vkGetMemoryAndroidHardwareBufferANDROID(vkEnc, VK_SUCCESS, device, pInfo,
                                                              pBuffer);
    return vkGetMemoryAndroidHardwareBufferANDROID_VkResult_return;
}
#endif
#ifdef VK_EXT_inline_uniform_block
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_pipeline_creation_feedback
#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_EXT_metal_surface
#endif
#ifdef VK_EXT_subgroup_size_control
#endif
#ifdef VK_EXT_tooling_info
static VkResult entry_vkGetPhysicalDeviceToolPropertiesEXT(
    VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
    VkPhysicalDeviceToolProperties* pToolProperties) {
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceToolPropertiesEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return =
        vkEnc->vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties,
                                                    true /* do lock */);
    return vkGetPhysicalDeviceToolPropertiesEXT_VkResult_return;
}
#endif
#ifdef VK_EXT_provoking_vertex
#endif
#ifdef VK_EXT_line_rasterization
static void entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
                                         uint16_t lineStipplePattern) {
    AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
                                  true /* do lock */);
}
static void dynCheck_entry_vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer,
                                                  uint32_t lineStippleFactor,
                                                  uint16_t lineStipplePattern) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_line_rasterization")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetLineStippleEXT", "VK_EXT_line_rasterization");
    }
    AEMU_SCOPED_TRACE("vkCmdSetLineStippleEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern,
                                  true /* do lock */);
}
#endif
#ifdef VK_EXT_index_type_uint8
#endif
#ifdef VK_EXT_extended_dynamic_state
static void entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
    AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetCullModeEXT(VkCommandBuffer commandBuffer,
                                               VkCullModeFlags cullMode) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetCullModeEXT", "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetCullModeEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetCullModeEXT(commandBuffer, cullMode, true /* do lock */);
}
static void entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
    AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetFrontFaceEXT(VkCommandBuffer commandBuffer,
                                                VkFrontFace frontFace) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetFrontFaceEXT", "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetFrontFaceEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetFrontFaceEXT(commandBuffer, frontFace, true /* do lock */);
}
static void entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
                                               VkPrimitiveTopology primitiveTopology) {
    AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer,
                                                        VkPrimitiveTopology primitiveTopology) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveTopologyEXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetPrimitiveTopologyEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology, true /* do lock */);
}
static void entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
                                               uint32_t viewportCount,
                                               const VkViewport* pViewports) {
    AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
                                        true /* do lock */);
}
static void dynCheck_entry_vkCmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer,
                                                        uint32_t viewportCount,
                                                        const VkViewport* pViewports) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetViewportWithCountEXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetViewportWithCountEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports,
                                        true /* do lock */);
}
static void entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount,
                                              const VkRect2D* pScissors) {
    AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer,
                                                       uint32_t scissorCount,
                                                       const VkRect2D* pScissors) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetScissorWithCountEXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetScissorWithCountEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors, true /* do lock */);
}
static void entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding,
                                             uint32_t bindingCount, const VkBuffer* pBuffers,
                                             const VkDeviceSize* pOffsets,
                                             const VkDeviceSize* pSizes,
                                             const VkDeviceSize* pStrides) {
    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
                                      pSizes, pStrides, true /* do lock */);
}
static void dynCheck_entry_vkCmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer,
                                                      uint32_t firstBinding, uint32_t bindingCount,
                                                      const VkBuffer* pBuffers,
                                                      const VkDeviceSize* pOffsets,
                                                      const VkDeviceSize* pSizes,
                                                      const VkDeviceSize* pStrides) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdBindVertexBuffers2EXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers2EXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets,
                                      pSizes, pStrides, true /* do lock */);
}
static void entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
                                             VkBool32 depthTestEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer,
                                                      VkBool32 depthTestEnable) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthTestEnableEXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetDepthTestEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable, true /* do lock */);
}
static void entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
                                              VkBool32 depthWriteEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer,
                                                       VkBool32 depthWriteEnable) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthWriteEnableEXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetDepthWriteEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable, true /* do lock */);
}
static void entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
                                            VkCompareOp depthCompareOp) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer,
                                                     VkCompareOp depthCompareOp) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthCompareOpEXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetDepthCompareOpEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp, true /* do lock */);
}
static void entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
                                                   VkBool32 depthBoundsTestEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
                                            true /* do lock */);
}
static void dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer,
                                                            VkBool32 depthBoundsTestEnable) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBoundsTestEnableEXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetDepthBoundsTestEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable,
                                            true /* do lock */);
}
static void entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
                                               VkBool32 stencilTestEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer,
                                                        VkBool32 stencilTestEnable) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilTestEnableEXT",
                                         "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetStencilTestEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable, true /* do lock */);
}
static void entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask,
                                       VkStencilOp failOp, VkStencilOp passOp,
                                       VkStencilOp depthFailOp, VkCompareOp compareOp) {
    AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
                                true /* do lock */);
}
static void dynCheck_entry_vkCmdSetStencilOpEXT(VkCommandBuffer commandBuffer,
                                                VkStencilFaceFlags faceMask, VkStencilOp failOp,
                                                VkStencilOp passOp, VkStencilOp depthFailOp,
                                                VkCompareOp compareOp) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetStencilOpEXT", "VK_EXT_extended_dynamic_state");
    }
    AEMU_SCOPED_TRACE("vkCmdSetStencilOpEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp,
                                true /* do lock */);
}
#endif
#ifdef VK_EXT_host_image_copy
static VkResult entry_vkCopyMemoryToImageEXT(
    VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
    AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
    vkCopyMemoryToImageEXT_VkResult_return =
        vkEnc->vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo, true /* do lock */);
    return vkCopyMemoryToImageEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkCopyMemoryToImageEXT(
    VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
        sOnInvalidDynamicallyCheckedCall("vkCopyMemoryToImageEXT", "VK_EXT_host_image_copy");
    }
    AEMU_SCOPED_TRACE("vkCopyMemoryToImageEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCopyMemoryToImageEXT_VkResult_return = (VkResult)0;
    vkCopyMemoryToImageEXT_VkResult_return =
        vkEnc->vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo, true /* do lock */);
    return vkCopyMemoryToImageEXT_VkResult_return;
}
static VkResult entry_vkCopyImageToMemoryEXT(
    VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
    AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
    vkCopyImageToMemoryEXT_VkResult_return =
        vkEnc->vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo, true /* do lock */);
    return vkCopyImageToMemoryEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkCopyImageToMemoryEXT(
    VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
        sOnInvalidDynamicallyCheckedCall("vkCopyImageToMemoryEXT", "VK_EXT_host_image_copy");
    }
    AEMU_SCOPED_TRACE("vkCopyImageToMemoryEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCopyImageToMemoryEXT_VkResult_return = (VkResult)0;
    vkCopyImageToMemoryEXT_VkResult_return =
        vkEnc->vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo, true /* do lock */);
    return vkCopyImageToMemoryEXT_VkResult_return;
}
static VkResult entry_vkCopyImageToImageEXT(
    VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
    AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
    vkCopyImageToImageEXT_VkResult_return =
        vkEnc->vkCopyImageToImageEXT(device, pCopyImageToImageInfo, true /* do lock */);
    return vkCopyImageToImageEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkCopyImageToImageEXT(
    VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
        sOnInvalidDynamicallyCheckedCall("vkCopyImageToImageEXT", "VK_EXT_host_image_copy");
    }
    AEMU_SCOPED_TRACE("vkCopyImageToImageEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCopyImageToImageEXT_VkResult_return = (VkResult)0;
    vkCopyImageToImageEXT_VkResult_return =
        vkEnc->vkCopyImageToImageEXT(device, pCopyImageToImageInfo, true /* do lock */);
    return vkCopyImageToImageEXT_VkResult_return;
}
static VkResult entry_vkTransitionImageLayoutEXT(
    VkDevice device, uint32_t transitionCount,
    const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
    AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
    vkTransitionImageLayoutEXT_VkResult_return = vkEnc->vkTransitionImageLayoutEXT(
        device, transitionCount, pTransitions, true /* do lock */);
    return vkTransitionImageLayoutEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkTransitionImageLayoutEXT(
    VkDevice device, uint32_t transitionCount,
    const VkHostImageLayoutTransitionInfoEXT* pTransitions) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
        sOnInvalidDynamicallyCheckedCall("vkTransitionImageLayoutEXT", "VK_EXT_host_image_copy");
    }
    AEMU_SCOPED_TRACE("vkTransitionImageLayoutEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkTransitionImageLayoutEXT_VkResult_return = (VkResult)0;
    vkTransitionImageLayoutEXT_VkResult_return = vkEnc->vkTransitionImageLayoutEXT(
        device, transitionCount, pTransitions, true /* do lock */);
    return vkTransitionImageLayoutEXT_VkResult_return;
}
static void entry_vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image,
                                                  const VkImageSubresource2KHR* pSubresource,
                                                  VkSubresourceLayout2KHR* pLayout) {
    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout,
                                           true /* do lock */);
}
static void dynCheck_entry_vkGetImageSubresourceLayout2EXT(
    VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource,
    VkSubresourceLayout2KHR* pLayout) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_host_image_copy")) {
        sOnInvalidDynamicallyCheckedCall("vkGetImageSubresourceLayout2EXT",
                                         "VK_EXT_host_image_copy");
    }
    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout2EXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout,
                                           true /* do lock */);
}
#endif
#ifdef VK_EXT_swapchain_maintenance1
static VkResult entry_vkReleaseSwapchainImagesEXT(
    VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) {
    AEMU_SCOPED_TRACE("vkReleaseSwapchainImagesEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkReleaseSwapchainImagesEXT_VkResult_return = (VkResult)0;
    vkReleaseSwapchainImagesEXT_VkResult_return =
        vkEnc->vkReleaseSwapchainImagesEXT(device, pReleaseInfo, true /* do lock */);
    return vkReleaseSwapchainImagesEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkReleaseSwapchainImagesEXT(
    VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_swapchain_maintenance1")) {
        sOnInvalidDynamicallyCheckedCall("vkReleaseSwapchainImagesEXT",
                                         "VK_EXT_swapchain_maintenance1");
    }
    AEMU_SCOPED_TRACE("vkReleaseSwapchainImagesEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkReleaseSwapchainImagesEXT_VkResult_return = (VkResult)0;
    vkReleaseSwapchainImagesEXT_VkResult_return =
        vkEnc->vkReleaseSwapchainImagesEXT(device, pReleaseInfo, true /* do lock */);
    return vkReleaseSwapchainImagesEXT_VkResult_return;
}
#endif
#ifdef VK_EXT_shader_demote_to_helper_invocation
#endif
#ifdef VK_EXT_texel_buffer_alignment
#endif
#ifdef VK_EXT_device_memory_report
#endif
#ifdef VK_EXT_custom_border_color
#endif
#ifdef VK_EXT_private_data
static VkResult entry_vkCreatePrivateDataSlotEXT(VkDevice device,
                                                 const VkPrivateDataSlotCreateInfo* pCreateInfo,
                                                 const VkAllocationCallbacks* pAllocator,
                                                 VkPrivateDataSlot* pPrivateDataSlot) {
    AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
    vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
        device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
    return vkCreatePrivateDataSlotEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkCreatePrivateDataSlotEXT(
    VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
        sOnInvalidDynamicallyCheckedCall("vkCreatePrivateDataSlotEXT", "VK_EXT_private_data");
    }
    AEMU_SCOPED_TRACE("vkCreatePrivateDataSlotEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreatePrivateDataSlotEXT_VkResult_return = (VkResult)0;
    vkCreatePrivateDataSlotEXT_VkResult_return = vkEnc->vkCreatePrivateDataSlotEXT(
        device, pCreateInfo, pAllocator, pPrivateDataSlot, true /* do lock */);
    return vkCreatePrivateDataSlotEXT_VkResult_return;
}
static void entry_vkDestroyPrivateDataSlotEXT(VkDevice device, VkPrivateDataSlot privateDataSlot,
                                              const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
}
static void dynCheck_entry_vkDestroyPrivateDataSlotEXT(VkDevice device,
                                                       VkPrivateDataSlot privateDataSlot,
                                                       const VkAllocationCallbacks* pAllocator) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
        sOnInvalidDynamicallyCheckedCall("vkDestroyPrivateDataSlotEXT", "VK_EXT_private_data");
    }
    AEMU_SCOPED_TRACE("vkDestroyPrivateDataSlotEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator, true /* do lock */);
}
static VkResult entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
                                          uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
                                          uint64_t data) {
    AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
    vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
        device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
    return vkSetPrivateDataEXT_VkResult_return;
}
static VkResult dynCheck_entry_vkSetPrivateDataEXT(VkDevice device, VkObjectType objectType,
                                                   uint64_t objectHandle,
                                                   VkPrivateDataSlot privateDataSlot,
                                                   uint64_t data) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
        sOnInvalidDynamicallyCheckedCall("vkSetPrivateDataEXT", "VK_EXT_private_data");
    }
    AEMU_SCOPED_TRACE("vkSetPrivateDataEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkSetPrivateDataEXT_VkResult_return = (VkResult)0;
    vkSetPrivateDataEXT_VkResult_return = vkEnc->vkSetPrivateDataEXT(
        device, objectType, objectHandle, privateDataSlot, data, true /* do lock */);
    return vkSetPrivateDataEXT_VkResult_return;
}
static void entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
                                      uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
                                      uint64_t* pData) {
    AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
                               true /* do lock */);
}
static void dynCheck_entry_vkGetPrivateDataEXT(VkDevice device, VkObjectType objectType,
                                               uint64_t objectHandle,
                                               VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_EXT_private_data")) {
        sOnInvalidDynamicallyCheckedCall("vkGetPrivateDataEXT", "VK_EXT_private_data");
    }
    AEMU_SCOPED_TRACE("vkGetPrivateDataEXT");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData,
                               true /* do lock */);
}
#endif
#ifdef VK_EXT_pipeline_creation_cache_control
#endif
#ifdef VK_EXT_graphics_pipeline_library
#endif
#ifdef VK_EXT_ycbcr_2plane_444_formats
#endif
#ifdef VK_EXT_image_robustness
#endif
#ifdef VK_EXT_image_compression_control
#endif
#ifdef VK_EXT_4444_formats
#endif
#ifdef VK_EXT_primitive_topology_list_restart
#endif
#ifdef VK_EXT_extended_dynamic_state2
static void entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
                                                uint32_t patchControlPoints) {
    AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer,
                                                         uint32_t patchControlPoints) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetPatchControlPointsEXT",
                                         "VK_EXT_extended_dynamic_state2");
    }
    AEMU_SCOPED_TRACE("vkCmdSetPatchControlPointsEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints, true /* do lock */);
}
static void entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
                                                     VkBool32 rasterizerDiscardEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
                                              true /* do lock */);
}
static void dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer,
                                                              VkBool32 rasterizerDiscardEnable) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetRasterizerDiscardEnableEXT",
                                         "VK_EXT_extended_dynamic_state2");
    }
    AEMU_SCOPED_TRACE("vkCmdSetRasterizerDiscardEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable,
                                              true /* do lock */);
}
static void entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
                                             VkBool32 depthBiasEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer,
                                                      VkBool32 depthBiasEnable) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetDepthBiasEnableEXT",
                                         "VK_EXT_extended_dynamic_state2");
    }
    AEMU_SCOPED_TRACE("vkCmdSetDepthBiasEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable, true /* do lock */);
}
static void entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
    AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
}
static void dynCheck_entry_vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetLogicOpEXT", "VK_EXT_extended_dynamic_state2");
    }
    AEMU_SCOPED_TRACE("vkCmdSetLogicOpEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetLogicOpEXT(commandBuffer, logicOp, true /* do lock */);
}
static void entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
                                                    VkBool32 primitiveRestartEnable) {
    AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
                                             true /* do lock */);
}
static void dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer,
                                                             VkBool32 primitiveRestartEnable) {
    auto resources = ResourceTracker::get();
    VkDevice device = resources->getDevice(commandBuffer);
    ;
    if (!resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2")) {
        sOnInvalidDynamicallyCheckedCall("vkCmdSetPrimitiveRestartEnableEXT",
                                         "VK_EXT_extended_dynamic_state2");
    }
    AEMU_SCOPED_TRACE("vkCmdSetPrimitiveRestartEnableEXT");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable,
                                             true /* do lock */);
}
#endif
#ifdef VK_GOOGLE_gfxstream
static VkResult entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device, VkDeviceMemory memory,
                                                        uint64_t* pAddress) {
    AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
    vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
        vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
    return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device,
                                                                 VkDeviceMemory memory,
                                                                 uint64_t* pAddress) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkMapMemoryIntoAddressSpaceGOOGLE",
                                         "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
    vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return =
        vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress, true /* do lock */);
    return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
}
static void entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
    VkDevice device, VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
    uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
    const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
    const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
    const VkBufferView* pBufferViews) {
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
        device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
        bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
        pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
}
static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
    VkDevice device, VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
    uint32_t bufferInfoCount, uint32_t bufferViewCount, const uint32_t* pImageInfoEntryIndices,
    const uint32_t* pBufferInfoEntryIndices, const uint32_t* pBufferViewEntryIndices,
    const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
    const VkBufferView* pBufferViews) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSizedGOOGLE",
                                         "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
        device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
        bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
        pImageInfos, pBufferInfos, pBufferViews, true /* do lock */);
}
static void entry_vkBeginCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
                                                  const VkCommandBufferBeginInfo* pBeginInfo) {
    AEMU_SCOPED_TRACE("vkBeginCommandBufferAsyncGOOGLE");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkBeginCommandBufferAsyncGOOGLE(commandBuffer, pBeginInfo, true /* do lock */);
}
static void entry_vkEndCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer) {
    AEMU_SCOPED_TRACE("vkEndCommandBufferAsyncGOOGLE");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkEndCommandBufferAsyncGOOGLE(commandBuffer, true /* do lock */);
}
static void entry_vkResetCommandBufferAsyncGOOGLE(VkCommandBuffer commandBuffer,
                                                  VkCommandBufferResetFlags flags) {
    AEMU_SCOPED_TRACE("vkResetCommandBufferAsyncGOOGLE");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkResetCommandBufferAsyncGOOGLE(commandBuffer, flags, true /* do lock */);
}
static void entry_vkCommandBufferHostSyncGOOGLE(VkCommandBuffer commandBuffer,
                                                uint32_t needHostSync, uint32_t sequenceNumber) {
    AEMU_SCOPED_TRACE("vkCommandBufferHostSyncGOOGLE");
    auto vkEnc = ResourceTracker::getCommandBufferEncoder(commandBuffer);
    vkEnc->vkCommandBufferHostSyncGOOGLE(commandBuffer, needHostSync, sequenceNumber,
                                         true /* do lock */);
}
static VkResult entry_vkCreateImageWithRequirementsGOOGLE(
    VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
    VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
    vkCreateImageWithRequirementsGOOGLE_VkResult_return =
        vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
                                                   pMemoryRequirements, true /* do lock */);
    return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateImageWithRequirementsGOOGLE(
    VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
    VkImage* pImage, VkMemoryRequirements* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkCreateImageWithRequirementsGOOGLE",
                                         "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
    vkCreateImageWithRequirementsGOOGLE_VkResult_return =
        vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage,
                                                   pMemoryRequirements, true /* do lock */);
    return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
}
static VkResult entry_vkCreateBufferWithRequirementsGOOGLE(
    VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
    AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
    vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
        vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
                                                    pMemoryRequirements, true /* do lock */);
    return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE(
    VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer, VkMemoryRequirements* pMemoryRequirements) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkCreateBufferWithRequirementsGOOGLE",
                                         "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
    vkCreateBufferWithRequirementsGOOGLE_VkResult_return =
        vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer,
                                                    pMemoryRequirements, true /* do lock */);
    return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
}
static VkResult entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device, VkDeviceMemory memory,
                                                       uint64_t* pAddress, uint64_t* pSize,
                                                       uint64_t* pHostmemId) {
    AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
    vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
        device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
    return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE(VkDevice device,
                                                                VkDeviceMemory memory,
                                                                uint64_t* pAddress, uint64_t* pSize,
                                                                uint64_t* pHostmemId) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkGetMemoryHostAddressInfoGOOGLE", "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkGetMemoryHostAddressInfoGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = (VkResult)0;
    vkGetMemoryHostAddressInfoGOOGLE_VkResult_return = vkEnc->vkGetMemoryHostAddressInfoGOOGLE(
        device, memory, pAddress, pSize, pHostmemId, true /* do lock */);
    return vkGetMemoryHostAddressInfoGOOGLE_VkResult_return;
}
static VkResult entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
                                             const VkAllocationCallbacks* pAllocator) {
    AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
    vkFreeMemorySyncGOOGLE_VkResult_return =
        vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
    return vkFreeMemorySyncGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkFreeMemorySyncGOOGLE(VkDevice device, VkDeviceMemory memory,
                                                      const VkAllocationCallbacks* pAllocator) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkFreeMemorySyncGOOGLE", "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkFreeMemorySyncGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkFreeMemorySyncGOOGLE_VkResult_return = (VkResult)0;
    vkFreeMemorySyncGOOGLE_VkResult_return =
        vkEnc->vkFreeMemorySyncGOOGLE(device, memory, pAllocator, true /* do lock */);
    return vkFreeMemorySyncGOOGLE_VkResult_return;
}
static void entry_vkQueueHostSyncGOOGLE(VkQueue queue, uint32_t needHostSync,
                                        uint32_t sequenceNumber) {
    AEMU_SCOPED_TRACE("vkQueueHostSyncGOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueHostSyncGOOGLE(queue, needHostSync, sequenceNumber, true /* do lock */);
}
static void entry_vkQueueSubmitAsyncGOOGLE(VkQueue queue, uint32_t submitCount,
                                           const VkSubmitInfo* pSubmits, VkFence fence) {
    AEMU_SCOPED_TRACE("vkQueueSubmitAsyncGOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueSubmitAsyncGOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
}
static void entry_vkQueueWaitIdleAsyncGOOGLE(VkQueue queue) {
    AEMU_SCOPED_TRACE("vkQueueWaitIdleAsyncGOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueWaitIdleAsyncGOOGLE(queue, true /* do lock */);
}
static void entry_vkQueueBindSparseAsyncGOOGLE(VkQueue queue, uint32_t bindInfoCount,
                                               const VkBindSparseInfo* pBindInfo, VkFence fence) {
    AEMU_SCOPED_TRACE("vkQueueBindSparseAsyncGOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueBindSparseAsyncGOOGLE(queue, bindInfoCount, pBindInfo, fence, true /* do lock */);
}
static void entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
                                               VkDeviceSize* pOffset,
                                               VkDeviceSize* pRowPitchAlignment) {
    AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
                                        true /* do lock */);
}
static void dynCheck_entry_vkGetLinearImageLayoutGOOGLE(VkDevice device, VkFormat format,
                                                        VkDeviceSize* pOffset,
                                                        VkDeviceSize* pRowPitchAlignment) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayoutGOOGLE", "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkGetLinearImageLayoutGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetLinearImageLayoutGOOGLE(device, format, pOffset, pRowPitchAlignment,
                                        true /* do lock */);
}
static void entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
                                                const VkImageCreateInfo* pCreateInfo,
                                                VkDeviceSize* pOffset,
                                                VkDeviceSize* pRowPitchAlignment) {
    AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
                                         true /* do lock */);
}
static void dynCheck_entry_vkGetLinearImageLayout2GOOGLE(VkDevice device,
                                                         const VkImageCreateInfo* pCreateInfo,
                                                         VkDeviceSize* pOffset,
                                                         VkDeviceSize* pRowPitchAlignment) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkGetLinearImageLayout2GOOGLE", "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkGetLinearImageLayout2GOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkGetLinearImageLayout2GOOGLE(device, pCreateInfo, pOffset, pRowPitchAlignment,
                                         true /* do lock */);
}
static void entry_vkQueueFlushCommandsGOOGLE(VkQueue queue, VkCommandBuffer commandBuffer,
                                             VkDeviceSize dataSize, const void* pData) {
    AEMU_SCOPED_TRACE("vkQueueFlushCommandsGOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueFlushCommandsGOOGLE(queue, commandBuffer, dataSize, pData, true /* do lock */);
}
static void entry_vkQueueCommitDescriptorSetUpdatesGOOGLE(
    VkQueue queue, uint32_t descriptorPoolCount, const VkDescriptorPool* pDescriptorPools,
    uint32_t descriptorSetCount, const VkDescriptorSetLayout* pSetLayouts,
    const uint64_t* pDescriptorSetPoolIds, const uint32_t* pDescriptorSetWhichPool,
    const uint32_t* pDescriptorSetPendingAllocation,
    const uint32_t* pDescriptorWriteStartingIndices, uint32_t pendingDescriptorWriteCount,
    const VkWriteDescriptorSet* pPendingDescriptorWrites) {
    AEMU_SCOPED_TRACE("vkQueueCommitDescriptorSetUpdatesGOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueCommitDescriptorSetUpdatesGOOGLE(
        queue, descriptorPoolCount, pDescriptorPools, descriptorSetCount, pSetLayouts,
        pDescriptorSetPoolIds, pDescriptorSetWhichPool, pDescriptorSetPendingAllocation,
        pDescriptorWriteStartingIndices, pendingDescriptorWriteCount, pPendingDescriptorWrites,
        true /* do lock */);
}
static void entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device, VkDescriptorPool descriptorPool,
                                                   uint32_t* pPoolIdCount, uint64_t* pPoolIds) {
    AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
                                            true /* do lock */);
}
static void dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE(VkDevice device,
                                                            VkDescriptorPool descriptorPool,
                                                            uint32_t* pPoolIdCount,
                                                            uint64_t* pPoolIds) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkCollectDescriptorPoolIdsGOOGLE", "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkCollectDescriptorPoolIdsGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkCollectDescriptorPoolIdsGOOGLE(device, descriptorPool, pPoolIdCount, pPoolIds,
                                            true /* do lock */);
}
static void entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(VkQueue queue,
                                                              uint32_t waitSemaphoreCount,
                                                              const VkSemaphore* pWaitSemaphores,
                                                              VkImage image) {
    AEMU_SCOPED_TRACE("vkQueueSignalReleaseImageANDROIDAsyncGOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueSignalReleaseImageANDROIDAsyncGOOGLE(queue, waitSemaphoreCount, pWaitSemaphores,
                                                       image, true /* do lock */);
}
static void entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue,
                                                          VkCommandBuffer commandBuffer,
                                                          VkDeviceMemory deviceMemory,
                                                          VkDeviceSize dataOffset,
                                                          VkDeviceSize dataSize) {
    AEMU_SCOPED_TRACE("vkQueueFlushCommandsFromAuxMemoryGOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueFlushCommandsFromAuxMemoryGOOGLE(queue, commandBuffer, deviceMemory, dataOffset,
                                                   dataSize, true /* do lock */);
}
static VkResult entry_vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
    AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
    vkGetBlobGOOGLE_VkResult_return = vkEnc->vkGetBlobGOOGLE(device, memory, true /* do lock */);
    return vkGetBlobGOOGLE_VkResult_return;
}
static VkResult dynCheck_entry_vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkGetBlobGOOGLE", "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkGetBlobGOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    VkResult vkGetBlobGOOGLE_VkResult_return = (VkResult)0;
    vkGetBlobGOOGLE_VkResult_return = vkEnc->vkGetBlobGOOGLE(device, memory, true /* do lock */);
    return vkGetBlobGOOGLE_VkResult_return;
}
static void entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
    VkDevice device, VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
    uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
    const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
    const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
    const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
    const uint8_t* pInlineUniformBlockData) {
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
        device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
        bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
        pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData,
        true /* do lock */);
}
static void dynCheck_entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
    VkDevice device, VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
    uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
    const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
    const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
    const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
    const uint8_t* pInlineUniformBlockData) {
    auto resources = ResourceTracker::get();
    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream")) {
        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSized2GOOGLE",
                                         "VK_GOOGLE_gfxstream");
    }
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
    auto vkEnc = ResourceTracker::getThreadLocalEncoder();
    vkEnc->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
        device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount,
        bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
        pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData,
        true /* do lock */);
}
static void entry_vkQueueSubmitAsync2GOOGLE(VkQueue queue, uint32_t submitCount,
                                            const VkSubmitInfo2* pSubmits, VkFence fence) {
    AEMU_SCOPED_TRACE("vkQueueSubmitAsync2GOOGLE");
    auto vkEnc = ResourceTracker::getQueueEncoder(queue);
    vkEnc->vkQueueSubmitAsync2GOOGLE(queue, submitCount, pSubmits, fence, true /* do lock */);
}
#endif
#ifdef VK_EXT_load_store_op_none
#endif
#ifdef VK_EXT_image_compression_control_swapchain
#endif
void* goldfish_vulkan_get_proc_address(const char* name) {
#ifdef VK_VERSION_1_0
    if (!strcmp(name, "vkCreateInstance")) {
        return (void*)entry_vkCreateInstance;
    }
    if (!strcmp(name, "vkDestroyInstance")) {
        return (void*)entry_vkDestroyInstance;
    }
    if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
        return (void*)entry_vkEnumeratePhysicalDevices;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
        return (void*)entry_vkGetPhysicalDeviceFeatures;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceFormatProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
        return (void*)entry_vkGetPhysicalDeviceProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
        return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
    }
    if (!strcmp(name, "vkGetInstanceProcAddr")) {
        return (void*)entry_vkGetInstanceProcAddr;
    }
    if (!strcmp(name, "vkGetDeviceProcAddr")) {
        return (void*)entry_vkGetDeviceProcAddr;
    }
    if (!strcmp(name, "vkCreateDevice")) {
        return (void*)entry_vkCreateDevice;
    }
    if (!strcmp(name, "vkDestroyDevice")) {
        return (void*)entry_vkDestroyDevice;
    }
    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
        return (void*)entry_vkEnumerateInstanceExtensionProperties;
    }
    if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
        return (void*)entry_vkEnumerateDeviceExtensionProperties;
    }
    if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
        return (void*)entry_vkEnumerateInstanceLayerProperties;
    }
    if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
        return (void*)entry_vkEnumerateDeviceLayerProperties;
    }
    if (!strcmp(name, "vkGetDeviceQueue")) {
        return (void*)entry_vkGetDeviceQueue;
    }
    if (!strcmp(name, "vkQueueSubmit")) {
        return (void*)entry_vkQueueSubmit;
    }
    if (!strcmp(name, "vkQueueWaitIdle")) {
        return (void*)entry_vkQueueWaitIdle;
    }
    if (!strcmp(name, "vkDeviceWaitIdle")) {
        return (void*)entry_vkDeviceWaitIdle;
    }
    if (!strcmp(name, "vkAllocateMemory")) {
        return (void*)entry_vkAllocateMemory;
    }
    if (!strcmp(name, "vkFreeMemory")) {
        return (void*)entry_vkFreeMemory;
    }
    if (!strcmp(name, "vkMapMemory")) {
        return (void*)entry_vkMapMemory;
    }
    if (!strcmp(name, "vkUnmapMemory")) {
        return (void*)entry_vkUnmapMemory;
    }
    if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
        return (void*)entry_vkFlushMappedMemoryRanges;
    }
    if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
        return (void*)entry_vkInvalidateMappedMemoryRanges;
    }
    if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
        return (void*)entry_vkGetDeviceMemoryCommitment;
    }
    if (!strcmp(name, "vkBindBufferMemory")) {
        return (void*)entry_vkBindBufferMemory;
    }
    if (!strcmp(name, "vkBindImageMemory")) {
        return (void*)entry_vkBindImageMemory;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
        return (void*)entry_vkGetBufferMemoryRequirements;
    }
    if (!strcmp(name, "vkGetImageMemoryRequirements")) {
        return (void*)entry_vkGetImageMemoryRequirements;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
        return (void*)entry_vkGetImageSparseMemoryRequirements;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
    }
    if (!strcmp(name, "vkQueueBindSparse")) {
        return (void*)entry_vkQueueBindSparse;
    }
    if (!strcmp(name, "vkCreateFence")) {
        return (void*)entry_vkCreateFence;
    }
    if (!strcmp(name, "vkDestroyFence")) {
        return (void*)entry_vkDestroyFence;
    }
    if (!strcmp(name, "vkResetFences")) {
        return (void*)entry_vkResetFences;
    }
    if (!strcmp(name, "vkGetFenceStatus")) {
        return (void*)entry_vkGetFenceStatus;
    }
    if (!strcmp(name, "vkWaitForFences")) {
        return (void*)entry_vkWaitForFences;
    }
    if (!strcmp(name, "vkCreateSemaphore")) {
        return (void*)entry_vkCreateSemaphore;
    }
    if (!strcmp(name, "vkDestroySemaphore")) {
        return (void*)entry_vkDestroySemaphore;
    }
    if (!strcmp(name, "vkCreateEvent")) {
        return (void*)entry_vkCreateEvent;
    }
    if (!strcmp(name, "vkDestroyEvent")) {
        return (void*)entry_vkDestroyEvent;
    }
    if (!strcmp(name, "vkGetEventStatus")) {
        return (void*)entry_vkGetEventStatus;
    }
    if (!strcmp(name, "vkSetEvent")) {
        return (void*)entry_vkSetEvent;
    }
    if (!strcmp(name, "vkResetEvent")) {
        return (void*)entry_vkResetEvent;
    }
    if (!strcmp(name, "vkCreateQueryPool")) {
        return (void*)entry_vkCreateQueryPool;
    }
    if (!strcmp(name, "vkDestroyQueryPool")) {
        return (void*)entry_vkDestroyQueryPool;
    }
    if (!strcmp(name, "vkGetQueryPoolResults")) {
        return (void*)entry_vkGetQueryPoolResults;
    }
    if (!strcmp(name, "vkCreateBuffer")) {
        return (void*)entry_vkCreateBuffer;
    }
    if (!strcmp(name, "vkDestroyBuffer")) {
        return (void*)entry_vkDestroyBuffer;
    }
    if (!strcmp(name, "vkCreateBufferView")) {
        return (void*)entry_vkCreateBufferView;
    }
    if (!strcmp(name, "vkDestroyBufferView")) {
        return (void*)entry_vkDestroyBufferView;
    }
    if (!strcmp(name, "vkCreateImage")) {
        return (void*)entry_vkCreateImage;
    }
    if (!strcmp(name, "vkDestroyImage")) {
        return (void*)entry_vkDestroyImage;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout")) {
        return (void*)entry_vkGetImageSubresourceLayout;
    }
    if (!strcmp(name, "vkCreateImageView")) {
        return (void*)entry_vkCreateImageView;
    }
    if (!strcmp(name, "vkDestroyImageView")) {
        return (void*)entry_vkDestroyImageView;
    }
    if (!strcmp(name, "vkCreateShaderModule")) {
        return (void*)entry_vkCreateShaderModule;
    }
    if (!strcmp(name, "vkDestroyShaderModule")) {
        return (void*)entry_vkDestroyShaderModule;
    }
    if (!strcmp(name, "vkCreatePipelineCache")) {
        return (void*)entry_vkCreatePipelineCache;
    }
    if (!strcmp(name, "vkDestroyPipelineCache")) {
        return (void*)entry_vkDestroyPipelineCache;
    }
    if (!strcmp(name, "vkGetPipelineCacheData")) {
        return (void*)entry_vkGetPipelineCacheData;
    }
    if (!strcmp(name, "vkMergePipelineCaches")) {
        return (void*)entry_vkMergePipelineCaches;
    }
    if (!strcmp(name, "vkCreateGraphicsPipelines")) {
        return (void*)entry_vkCreateGraphicsPipelines;
    }
    if (!strcmp(name, "vkCreateComputePipelines")) {
        return (void*)entry_vkCreateComputePipelines;
    }
    if (!strcmp(name, "vkDestroyPipeline")) {
        return (void*)entry_vkDestroyPipeline;
    }
    if (!strcmp(name, "vkCreatePipelineLayout")) {
        return (void*)entry_vkCreatePipelineLayout;
    }
    if (!strcmp(name, "vkDestroyPipelineLayout")) {
        return (void*)entry_vkDestroyPipelineLayout;
    }
    if (!strcmp(name, "vkCreateSampler")) {
        return (void*)entry_vkCreateSampler;
    }
    if (!strcmp(name, "vkDestroySampler")) {
        return (void*)entry_vkDestroySampler;
    }
    if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
        return (void*)entry_vkCreateDescriptorSetLayout;
    }
    if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
        return (void*)entry_vkDestroyDescriptorSetLayout;
    }
    if (!strcmp(name, "vkCreateDescriptorPool")) {
        return (void*)entry_vkCreateDescriptorPool;
    }
    if (!strcmp(name, "vkDestroyDescriptorPool")) {
        return (void*)entry_vkDestroyDescriptorPool;
    }
    if (!strcmp(name, "vkResetDescriptorPool")) {
        return (void*)entry_vkResetDescriptorPool;
    }
    if (!strcmp(name, "vkAllocateDescriptorSets")) {
        return (void*)entry_vkAllocateDescriptorSets;
    }
    if (!strcmp(name, "vkFreeDescriptorSets")) {
        return (void*)entry_vkFreeDescriptorSets;
    }
    if (!strcmp(name, "vkUpdateDescriptorSets")) {
        return (void*)entry_vkUpdateDescriptorSets;
    }
    if (!strcmp(name, "vkCreateFramebuffer")) {
        return (void*)entry_vkCreateFramebuffer;
    }
    if (!strcmp(name, "vkDestroyFramebuffer")) {
        return (void*)entry_vkDestroyFramebuffer;
    }
    if (!strcmp(name, "vkCreateRenderPass")) {
        return (void*)entry_vkCreateRenderPass;
    }
    if (!strcmp(name, "vkDestroyRenderPass")) {
        return (void*)entry_vkDestroyRenderPass;
    }
    if (!strcmp(name, "vkGetRenderAreaGranularity")) {
        return (void*)entry_vkGetRenderAreaGranularity;
    }
    if (!strcmp(name, "vkCreateCommandPool")) {
        return (void*)entry_vkCreateCommandPool;
    }
    if (!strcmp(name, "vkDestroyCommandPool")) {
        return (void*)entry_vkDestroyCommandPool;
    }
    if (!strcmp(name, "vkResetCommandPool")) {
        return (void*)entry_vkResetCommandPool;
    }
    if (!strcmp(name, "vkAllocateCommandBuffers")) {
        return (void*)entry_vkAllocateCommandBuffers;
    }
    if (!strcmp(name, "vkFreeCommandBuffers")) {
        return (void*)entry_vkFreeCommandBuffers;
    }
    if (!strcmp(name, "vkBeginCommandBuffer")) {
        return (void*)entry_vkBeginCommandBuffer;
    }
    if (!strcmp(name, "vkEndCommandBuffer")) {
        return (void*)entry_vkEndCommandBuffer;
    }
    if (!strcmp(name, "vkResetCommandBuffer")) {
        return (void*)entry_vkResetCommandBuffer;
    }
    if (!strcmp(name, "vkCmdBindPipeline")) {
        return (void*)entry_vkCmdBindPipeline;
    }
    if (!strcmp(name, "vkCmdSetViewport")) {
        return (void*)entry_vkCmdSetViewport;
    }
    if (!strcmp(name, "vkCmdSetScissor")) {
        return (void*)entry_vkCmdSetScissor;
    }
    if (!strcmp(name, "vkCmdSetLineWidth")) {
        return (void*)entry_vkCmdSetLineWidth;
    }
    if (!strcmp(name, "vkCmdSetDepthBias")) {
        return (void*)entry_vkCmdSetDepthBias;
    }
    if (!strcmp(name, "vkCmdSetBlendConstants")) {
        return (void*)entry_vkCmdSetBlendConstants;
    }
    if (!strcmp(name, "vkCmdSetDepthBounds")) {
        return (void*)entry_vkCmdSetDepthBounds;
    }
    if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
        return (void*)entry_vkCmdSetStencilCompareMask;
    }
    if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
        return (void*)entry_vkCmdSetStencilWriteMask;
    }
    if (!strcmp(name, "vkCmdSetStencilReference")) {
        return (void*)entry_vkCmdSetStencilReference;
    }
    if (!strcmp(name, "vkCmdBindDescriptorSets")) {
        return (void*)entry_vkCmdBindDescriptorSets;
    }
    if (!strcmp(name, "vkCmdBindIndexBuffer")) {
        return (void*)entry_vkCmdBindIndexBuffer;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers")) {
        return (void*)entry_vkCmdBindVertexBuffers;
    }
    if (!strcmp(name, "vkCmdDraw")) {
        return (void*)entry_vkCmdDraw;
    }
    if (!strcmp(name, "vkCmdDrawIndexed")) {
        return (void*)entry_vkCmdDrawIndexed;
    }
    if (!strcmp(name, "vkCmdDrawIndirect")) {
        return (void*)entry_vkCmdDrawIndirect;
    }
    if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
        return (void*)entry_vkCmdDrawIndexedIndirect;
    }
    if (!strcmp(name, "vkCmdDispatch")) {
        return (void*)entry_vkCmdDispatch;
    }
    if (!strcmp(name, "vkCmdDispatchIndirect")) {
        return (void*)entry_vkCmdDispatchIndirect;
    }
    if (!strcmp(name, "vkCmdCopyBuffer")) {
        return (void*)entry_vkCmdCopyBuffer;
    }
    if (!strcmp(name, "vkCmdCopyImage")) {
        return (void*)entry_vkCmdCopyImage;
    }
    if (!strcmp(name, "vkCmdBlitImage")) {
        return (void*)entry_vkCmdBlitImage;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage")) {
        return (void*)entry_vkCmdCopyBufferToImage;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
        return (void*)entry_vkCmdCopyImageToBuffer;
    }
    if (!strcmp(name, "vkCmdUpdateBuffer")) {
        return (void*)entry_vkCmdUpdateBuffer;
    }
    if (!strcmp(name, "vkCmdFillBuffer")) {
        return (void*)entry_vkCmdFillBuffer;
    }
    if (!strcmp(name, "vkCmdClearColorImage")) {
        return (void*)entry_vkCmdClearColorImage;
    }
    if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
        return (void*)entry_vkCmdClearDepthStencilImage;
    }
    if (!strcmp(name, "vkCmdClearAttachments")) {
        return (void*)entry_vkCmdClearAttachments;
    }
    if (!strcmp(name, "vkCmdResolveImage")) {
        return (void*)entry_vkCmdResolveImage;
    }
    if (!strcmp(name, "vkCmdSetEvent")) {
        return (void*)entry_vkCmdSetEvent;
    }
    if (!strcmp(name, "vkCmdResetEvent")) {
        return (void*)entry_vkCmdResetEvent;
    }
    if (!strcmp(name, "vkCmdWaitEvents")) {
        return (void*)entry_vkCmdWaitEvents;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier")) {
        return (void*)entry_vkCmdPipelineBarrier;
    }
    if (!strcmp(name, "vkCmdBeginQuery")) {
        return (void*)entry_vkCmdBeginQuery;
    }
    if (!strcmp(name, "vkCmdEndQuery")) {
        return (void*)entry_vkCmdEndQuery;
    }
    if (!strcmp(name, "vkCmdResetQueryPool")) {
        return (void*)entry_vkCmdResetQueryPool;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp")) {
        return (void*)entry_vkCmdWriteTimestamp;
    }
    if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
        return (void*)entry_vkCmdCopyQueryPoolResults;
    }
    if (!strcmp(name, "vkCmdPushConstants")) {
        return (void*)entry_vkCmdPushConstants;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass")) {
        return (void*)entry_vkCmdBeginRenderPass;
    }
    if (!strcmp(name, "vkCmdNextSubpass")) {
        return (void*)entry_vkCmdNextSubpass;
    }
    if (!strcmp(name, "vkCmdEndRenderPass")) {
        return (void*)entry_vkCmdEndRenderPass;
    }
    if (!strcmp(name, "vkCmdExecuteCommands")) {
        return (void*)entry_vkCmdExecuteCommands;
    }
#endif
#ifdef VK_VERSION_1_1
    if (!strcmp(name, "vkEnumerateInstanceVersion")) {
        return nullptr;
    }
    if (!strcmp(name, "vkBindBufferMemory2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkBindImageMemory2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDeviceMask")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdDispatchBase")) {
        return nullptr;
    }
    if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkTrimCommandPool")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceQueue2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
        return nullptr;
    }
    if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
        return nullptr;
    }
    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
        return nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
        return nullptr;
    }
#endif
#ifdef VK_VERSION_1_2
    if (!strcmp(name, "vkCmdDrawIndirectCount")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCreateRenderPass2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdNextSubpass2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdEndRenderPass2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkResetQueryPool")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
        return nullptr;
    }
    if (!strcmp(name, "vkWaitSemaphores")) {
        return nullptr;
    }
    if (!strcmp(name, "vkSignalSemaphore")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetBufferDeviceAddress")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
        return nullptr;
    }
#endif
#ifdef VK_VERSION_1_3
    if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCreatePrivateDataSlot")) {
        return nullptr;
    }
    if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
        return nullptr;
    }
    if (!strcmp(name, "vkSetPrivateData")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPrivateData")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetEvent2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdResetEvent2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdWaitEvents2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueSubmit2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdCopyBuffer2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImage2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBlitImage2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdResolveImage2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBeginRendering")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdEndRendering")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetCullMode")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetFrontFace")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetViewportWithCount")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetScissorWithCount")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilOp")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_swapchain
    if (!strcmp(name, "vkCreateSwapchainKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkDestroySwapchainKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetSwapchainImagesKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkAcquireNextImageKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueuePresentKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkAcquireNextImage2KHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_android_surface
    if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_dynamic_rendering
    if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdEndRenderingKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_get_physical_device_properties2
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_maintenance1
    if (!strcmp(name, "vkTrimCommandPoolKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_external_memory_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_external_semaphore_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_external_semaphore_fd
    if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_descriptor_update_template
    if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_create_renderpass2
    if (!strcmp(name, "vkCreateRenderPass2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_external_fence_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_external_fence_fd
    if (!strcmp(name, "vkImportFenceFdKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetFenceFdKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_get_memory_requirements2
    if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
    if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_bind_memory2
    if (!strcmp(name, "vkBindBufferMemory2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkBindImageMemory2KHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_maintenance3
    if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_buffer_device_address
    if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_pipeline_executable_properties
    if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_synchronization2
    if (!strcmp(name, "vkCmdSetEvent2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdResetEvent2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueSubmit2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_copy_commands2
    if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImage2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBlitImage2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdResolveImage2KHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_maintenance4
    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
        return nullptr;
    }
#endif
#ifdef VK_KHR_maintenance5
    if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
        return nullptr;
    }
#endif
#ifdef VK_ANDROID_native_buffer
    if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
        return nullptr;
    }
    if (!strcmp(name, "vkAcquireImageANDROID")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
        return nullptr;
    }
#endif
#ifdef VK_EXT_transform_feedback
    if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
        return nullptr;
    }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
    if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
        return nullptr;
    }
#endif
#ifdef VK_EXT_tooling_info
    if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
        return nullptr;
    }
#endif
#ifdef VK_EXT_line_rasterization
    if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
        return nullptr;
    }
#endif
#ifdef VK_EXT_extended_dynamic_state
    if (!strcmp(name, "vkCmdSetCullModeEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
        return nullptr;
    }
#endif
#ifdef VK_EXT_host_image_copy
    if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCopyImageToImageEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
        return nullptr;
    }
#endif
#ifdef VK_EXT_swapchain_maintenance1
    if (!strcmp(name, "vkReleaseSwapchainImagesEXT")) {
        return nullptr;
    }
#endif
#ifdef VK_EXT_private_data
    if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkSetPrivateDataEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetPrivateDataEXT")) {
        return nullptr;
    }
#endif
#ifdef VK_EXT_extended_dynamic_state2
    if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
        return nullptr;
    }
#endif
#ifdef VK_GOOGLE_gfxstream
    if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetBlobGOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
        return nullptr;
    }
    if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
        return nullptr;
    }
#endif
    return nullptr;
}
void* goldfish_vulkan_get_instance_proc_address(VkInstance instance, const char* name) {
    auto resources = ResourceTracker::get();
    bool has1_1OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_1;
    bool has1_2OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_2;
    bool has1_3OrHigher = resources->getApiVersionFromInstance(instance) >= VK_API_VERSION_1_3;
#ifdef VK_VERSION_1_0
    if (!strcmp(name, "vkCreateInstance")) {
        return (void*)entry_vkCreateInstance;
    }
    if (!strcmp(name, "vkDestroyInstance")) {
        return (void*)entry_vkDestroyInstance;
    }
    if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
        return (void*)entry_vkEnumeratePhysicalDevices;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
        return (void*)entry_vkGetPhysicalDeviceFeatures;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceFormatProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
        return (void*)entry_vkGetPhysicalDeviceProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
        return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
    }
    if (!strcmp(name, "vkGetInstanceProcAddr")) {
        return (void*)entry_vkGetInstanceProcAddr;
    }
    if (!strcmp(name, "vkGetDeviceProcAddr")) {
        return (void*)entry_vkGetDeviceProcAddr;
    }
    if (!strcmp(name, "vkCreateDevice")) {
        return (void*)entry_vkCreateDevice;
    }
    if (!strcmp(name, "vkDestroyDevice")) {
        return (void*)entry_vkDestroyDevice;
    }
    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
        return (void*)entry_vkEnumerateInstanceExtensionProperties;
    }
    if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
        return (void*)entry_vkEnumerateDeviceExtensionProperties;
    }
    if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
        return (void*)entry_vkEnumerateInstanceLayerProperties;
    }
    if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
        return (void*)entry_vkEnumerateDeviceLayerProperties;
    }
    if (!strcmp(name, "vkGetDeviceQueue")) {
        return (void*)entry_vkGetDeviceQueue;
    }
    if (!strcmp(name, "vkQueueSubmit")) {
        return (void*)entry_vkQueueSubmit;
    }
    if (!strcmp(name, "vkQueueWaitIdle")) {
        return (void*)entry_vkQueueWaitIdle;
    }
    if (!strcmp(name, "vkDeviceWaitIdle")) {
        return (void*)entry_vkDeviceWaitIdle;
    }
    if (!strcmp(name, "vkAllocateMemory")) {
        return (void*)entry_vkAllocateMemory;
    }
    if (!strcmp(name, "vkFreeMemory")) {
        return (void*)entry_vkFreeMemory;
    }
    if (!strcmp(name, "vkMapMemory")) {
        return (void*)entry_vkMapMemory;
    }
    if (!strcmp(name, "vkUnmapMemory")) {
        return (void*)entry_vkUnmapMemory;
    }
    if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
        return (void*)entry_vkFlushMappedMemoryRanges;
    }
    if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
        return (void*)entry_vkInvalidateMappedMemoryRanges;
    }
    if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
        return (void*)entry_vkGetDeviceMemoryCommitment;
    }
    if (!strcmp(name, "vkBindBufferMemory")) {
        return (void*)entry_vkBindBufferMemory;
    }
    if (!strcmp(name, "vkBindImageMemory")) {
        return (void*)entry_vkBindImageMemory;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
        return (void*)entry_vkGetBufferMemoryRequirements;
    }
    if (!strcmp(name, "vkGetImageMemoryRequirements")) {
        return (void*)entry_vkGetImageMemoryRequirements;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
        return (void*)entry_vkGetImageSparseMemoryRequirements;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
    }
    if (!strcmp(name, "vkQueueBindSparse")) {
        return (void*)entry_vkQueueBindSparse;
    }
    if (!strcmp(name, "vkCreateFence")) {
        return (void*)entry_vkCreateFence;
    }
    if (!strcmp(name, "vkDestroyFence")) {
        return (void*)entry_vkDestroyFence;
    }
    if (!strcmp(name, "vkResetFences")) {
        return (void*)entry_vkResetFences;
    }
    if (!strcmp(name, "vkGetFenceStatus")) {
        return (void*)entry_vkGetFenceStatus;
    }
    if (!strcmp(name, "vkWaitForFences")) {
        return (void*)entry_vkWaitForFences;
    }
    if (!strcmp(name, "vkCreateSemaphore")) {
        return (void*)entry_vkCreateSemaphore;
    }
    if (!strcmp(name, "vkDestroySemaphore")) {
        return (void*)entry_vkDestroySemaphore;
    }
    if (!strcmp(name, "vkCreateEvent")) {
        return (void*)entry_vkCreateEvent;
    }
    if (!strcmp(name, "vkDestroyEvent")) {
        return (void*)entry_vkDestroyEvent;
    }
    if (!strcmp(name, "vkGetEventStatus")) {
        return (void*)entry_vkGetEventStatus;
    }
    if (!strcmp(name, "vkSetEvent")) {
        return (void*)entry_vkSetEvent;
    }
    if (!strcmp(name, "vkResetEvent")) {
        return (void*)entry_vkResetEvent;
    }
    if (!strcmp(name, "vkCreateQueryPool")) {
        return (void*)entry_vkCreateQueryPool;
    }
    if (!strcmp(name, "vkDestroyQueryPool")) {
        return (void*)entry_vkDestroyQueryPool;
    }
    if (!strcmp(name, "vkGetQueryPoolResults")) {
        return (void*)entry_vkGetQueryPoolResults;
    }
    if (!strcmp(name, "vkCreateBuffer")) {
        return (void*)entry_vkCreateBuffer;
    }
    if (!strcmp(name, "vkDestroyBuffer")) {
        return (void*)entry_vkDestroyBuffer;
    }
    if (!strcmp(name, "vkCreateBufferView")) {
        return (void*)entry_vkCreateBufferView;
    }
    if (!strcmp(name, "vkDestroyBufferView")) {
        return (void*)entry_vkDestroyBufferView;
    }
    if (!strcmp(name, "vkCreateImage")) {
        return (void*)entry_vkCreateImage;
    }
    if (!strcmp(name, "vkDestroyImage")) {
        return (void*)entry_vkDestroyImage;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout")) {
        return (void*)entry_vkGetImageSubresourceLayout;
    }
    if (!strcmp(name, "vkCreateImageView")) {
        return (void*)entry_vkCreateImageView;
    }
    if (!strcmp(name, "vkDestroyImageView")) {
        return (void*)entry_vkDestroyImageView;
    }
    if (!strcmp(name, "vkCreateShaderModule")) {
        return (void*)entry_vkCreateShaderModule;
    }
    if (!strcmp(name, "vkDestroyShaderModule")) {
        return (void*)entry_vkDestroyShaderModule;
    }
    if (!strcmp(name, "vkCreatePipelineCache")) {
        return (void*)entry_vkCreatePipelineCache;
    }
    if (!strcmp(name, "vkDestroyPipelineCache")) {
        return (void*)entry_vkDestroyPipelineCache;
    }
    if (!strcmp(name, "vkGetPipelineCacheData")) {
        return (void*)entry_vkGetPipelineCacheData;
    }
    if (!strcmp(name, "vkMergePipelineCaches")) {
        return (void*)entry_vkMergePipelineCaches;
    }
    if (!strcmp(name, "vkCreateGraphicsPipelines")) {
        return (void*)entry_vkCreateGraphicsPipelines;
    }
    if (!strcmp(name, "vkCreateComputePipelines")) {
        return (void*)entry_vkCreateComputePipelines;
    }
    if (!strcmp(name, "vkDestroyPipeline")) {
        return (void*)entry_vkDestroyPipeline;
    }
    if (!strcmp(name, "vkCreatePipelineLayout")) {
        return (void*)entry_vkCreatePipelineLayout;
    }
    if (!strcmp(name, "vkDestroyPipelineLayout")) {
        return (void*)entry_vkDestroyPipelineLayout;
    }
    if (!strcmp(name, "vkCreateSampler")) {
        return (void*)entry_vkCreateSampler;
    }
    if (!strcmp(name, "vkDestroySampler")) {
        return (void*)entry_vkDestroySampler;
    }
    if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
        return (void*)entry_vkCreateDescriptorSetLayout;
    }
    if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
        return (void*)entry_vkDestroyDescriptorSetLayout;
    }
    if (!strcmp(name, "vkCreateDescriptorPool")) {
        return (void*)entry_vkCreateDescriptorPool;
    }
    if (!strcmp(name, "vkDestroyDescriptorPool")) {
        return (void*)entry_vkDestroyDescriptorPool;
    }
    if (!strcmp(name, "vkResetDescriptorPool")) {
        return (void*)entry_vkResetDescriptorPool;
    }
    if (!strcmp(name, "vkAllocateDescriptorSets")) {
        return (void*)entry_vkAllocateDescriptorSets;
    }
    if (!strcmp(name, "vkFreeDescriptorSets")) {
        return (void*)entry_vkFreeDescriptorSets;
    }
    if (!strcmp(name, "vkUpdateDescriptorSets")) {
        return (void*)entry_vkUpdateDescriptorSets;
    }
    if (!strcmp(name, "vkCreateFramebuffer")) {
        return (void*)entry_vkCreateFramebuffer;
    }
    if (!strcmp(name, "vkDestroyFramebuffer")) {
        return (void*)entry_vkDestroyFramebuffer;
    }
    if (!strcmp(name, "vkCreateRenderPass")) {
        return (void*)entry_vkCreateRenderPass;
    }
    if (!strcmp(name, "vkDestroyRenderPass")) {
        return (void*)entry_vkDestroyRenderPass;
    }
    if (!strcmp(name, "vkGetRenderAreaGranularity")) {
        return (void*)entry_vkGetRenderAreaGranularity;
    }
    if (!strcmp(name, "vkCreateCommandPool")) {
        return (void*)entry_vkCreateCommandPool;
    }
    if (!strcmp(name, "vkDestroyCommandPool")) {
        return (void*)entry_vkDestroyCommandPool;
    }
    if (!strcmp(name, "vkResetCommandPool")) {
        return (void*)entry_vkResetCommandPool;
    }
    if (!strcmp(name, "vkAllocateCommandBuffers")) {
        return (void*)entry_vkAllocateCommandBuffers;
    }
    if (!strcmp(name, "vkFreeCommandBuffers")) {
        return (void*)entry_vkFreeCommandBuffers;
    }
    if (!strcmp(name, "vkBeginCommandBuffer")) {
        return (void*)entry_vkBeginCommandBuffer;
    }
    if (!strcmp(name, "vkEndCommandBuffer")) {
        return (void*)entry_vkEndCommandBuffer;
    }
    if (!strcmp(name, "vkResetCommandBuffer")) {
        return (void*)entry_vkResetCommandBuffer;
    }
    if (!strcmp(name, "vkCmdBindPipeline")) {
        return (void*)entry_vkCmdBindPipeline;
    }
    if (!strcmp(name, "vkCmdSetViewport")) {
        return (void*)entry_vkCmdSetViewport;
    }
    if (!strcmp(name, "vkCmdSetScissor")) {
        return (void*)entry_vkCmdSetScissor;
    }
    if (!strcmp(name, "vkCmdSetLineWidth")) {
        return (void*)entry_vkCmdSetLineWidth;
    }
    if (!strcmp(name, "vkCmdSetDepthBias")) {
        return (void*)entry_vkCmdSetDepthBias;
    }
    if (!strcmp(name, "vkCmdSetBlendConstants")) {
        return (void*)entry_vkCmdSetBlendConstants;
    }
    if (!strcmp(name, "vkCmdSetDepthBounds")) {
        return (void*)entry_vkCmdSetDepthBounds;
    }
    if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
        return (void*)entry_vkCmdSetStencilCompareMask;
    }
    if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
        return (void*)entry_vkCmdSetStencilWriteMask;
    }
    if (!strcmp(name, "vkCmdSetStencilReference")) {
        return (void*)entry_vkCmdSetStencilReference;
    }
    if (!strcmp(name, "vkCmdBindDescriptorSets")) {
        return (void*)entry_vkCmdBindDescriptorSets;
    }
    if (!strcmp(name, "vkCmdBindIndexBuffer")) {
        return (void*)entry_vkCmdBindIndexBuffer;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers")) {
        return (void*)entry_vkCmdBindVertexBuffers;
    }
    if (!strcmp(name, "vkCmdDraw")) {
        return (void*)entry_vkCmdDraw;
    }
    if (!strcmp(name, "vkCmdDrawIndexed")) {
        return (void*)entry_vkCmdDrawIndexed;
    }
    if (!strcmp(name, "vkCmdDrawIndirect")) {
        return (void*)entry_vkCmdDrawIndirect;
    }
    if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
        return (void*)entry_vkCmdDrawIndexedIndirect;
    }
    if (!strcmp(name, "vkCmdDispatch")) {
        return (void*)entry_vkCmdDispatch;
    }
    if (!strcmp(name, "vkCmdDispatchIndirect")) {
        return (void*)entry_vkCmdDispatchIndirect;
    }
    if (!strcmp(name, "vkCmdCopyBuffer")) {
        return (void*)entry_vkCmdCopyBuffer;
    }
    if (!strcmp(name, "vkCmdCopyImage")) {
        return (void*)entry_vkCmdCopyImage;
    }
    if (!strcmp(name, "vkCmdBlitImage")) {
        return (void*)entry_vkCmdBlitImage;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage")) {
        return (void*)entry_vkCmdCopyBufferToImage;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
        return (void*)entry_vkCmdCopyImageToBuffer;
    }
    if (!strcmp(name, "vkCmdUpdateBuffer")) {
        return (void*)entry_vkCmdUpdateBuffer;
    }
    if (!strcmp(name, "vkCmdFillBuffer")) {
        return (void*)entry_vkCmdFillBuffer;
    }
    if (!strcmp(name, "vkCmdClearColorImage")) {
        return (void*)entry_vkCmdClearColorImage;
    }
    if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
        return (void*)entry_vkCmdClearDepthStencilImage;
    }
    if (!strcmp(name, "vkCmdClearAttachments")) {
        return (void*)entry_vkCmdClearAttachments;
    }
    if (!strcmp(name, "vkCmdResolveImage")) {
        return (void*)entry_vkCmdResolveImage;
    }
    if (!strcmp(name, "vkCmdSetEvent")) {
        return (void*)entry_vkCmdSetEvent;
    }
    if (!strcmp(name, "vkCmdResetEvent")) {
        return (void*)entry_vkCmdResetEvent;
    }
    if (!strcmp(name, "vkCmdWaitEvents")) {
        return (void*)entry_vkCmdWaitEvents;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier")) {
        return (void*)entry_vkCmdPipelineBarrier;
    }
    if (!strcmp(name, "vkCmdBeginQuery")) {
        return (void*)entry_vkCmdBeginQuery;
    }
    if (!strcmp(name, "vkCmdEndQuery")) {
        return (void*)entry_vkCmdEndQuery;
    }
    if (!strcmp(name, "vkCmdResetQueryPool")) {
        return (void*)entry_vkCmdResetQueryPool;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp")) {
        return (void*)entry_vkCmdWriteTimestamp;
    }
    if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
        return (void*)entry_vkCmdCopyQueryPoolResults;
    }
    if (!strcmp(name, "vkCmdPushConstants")) {
        return (void*)entry_vkCmdPushConstants;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass")) {
        return (void*)entry_vkCmdBeginRenderPass;
    }
    if (!strcmp(name, "vkCmdNextSubpass")) {
        return (void*)entry_vkCmdNextSubpass;
    }
    if (!strcmp(name, "vkCmdEndRenderPass")) {
        return (void*)entry_vkCmdEndRenderPass;
    }
    if (!strcmp(name, "vkCmdExecuteCommands")) {
        return (void*)entry_vkCmdExecuteCommands;
    }
#endif
#ifdef VK_VERSION_1_1
    if (!strcmp(name, "vkEnumerateInstanceVersion")) {
        return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
    }
    if (!strcmp(name, "vkBindBufferMemory2")) {
        return (void*)dynCheck_entry_vkBindBufferMemory2;
    }
    if (!strcmp(name, "vkBindImageMemory2")) {
        return (void*)dynCheck_entry_vkBindImageMemory2;
    }
    if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
        return (void*)dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures;
    }
    if (!strcmp(name, "vkCmdSetDeviceMask")) {
        return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
    }
    if (!strcmp(name, "vkCmdDispatchBase")) {
        return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
    }
    if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
        return (void*)dynCheck_entry_vkGetImageMemoryRequirements2;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
        return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
        return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
                              : nullptr;
    }
    if (!strcmp(name, "vkTrimCommandPool")) {
        return (void*)dynCheck_entry_vkTrimCommandPool;
    }
    if (!strcmp(name, "vkGetDeviceQueue2")) {
        return (void*)dynCheck_entry_vkGetDeviceQueue2;
    }
    if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
        return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversion;
    }
    if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
        return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversion;
    }
    if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
        return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplate;
    }
    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
        return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplate;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
        return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplate;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
                              : nullptr;
    }
    if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
        return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupport;
    }
#endif
#ifdef VK_VERSION_1_2
    if (!strcmp(name, "vkCmdDrawIndirectCount")) {
        return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
    }
    if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
        return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
    }
    if (!strcmp(name, "vkCreateRenderPass2")) {
        return (void*)dynCheck_entry_vkCreateRenderPass2;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass2")) {
        return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
    }
    if (!strcmp(name, "vkCmdNextSubpass2")) {
        return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
    }
    if (!strcmp(name, "vkCmdEndRenderPass2")) {
        return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
    }
    if (!strcmp(name, "vkResetQueryPool")) {
        return (void*)dynCheck_entry_vkResetQueryPool;
    }
    if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
        return (void*)dynCheck_entry_vkGetSemaphoreCounterValue;
    }
    if (!strcmp(name, "vkWaitSemaphores")) {
        return (void*)dynCheck_entry_vkWaitSemaphores;
    }
    if (!strcmp(name, "vkSignalSemaphore")) {
        return (void*)dynCheck_entry_vkSignalSemaphore;
    }
    if (!strcmp(name, "vkGetBufferDeviceAddress")) {
        return (void*)dynCheck_entry_vkGetBufferDeviceAddress;
    }
    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
        return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddress;
    }
    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
        return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddress;
    }
#endif
#ifdef VK_VERSION_1_3
    if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
        return has1_3OrHigher ? (void*)entry_vkGetPhysicalDeviceToolProperties : nullptr;
    }
    if (!strcmp(name, "vkCreatePrivateDataSlot")) {
        return (void*)dynCheck_entry_vkCreatePrivateDataSlot;
    }
    if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
        return (void*)dynCheck_entry_vkDestroyPrivateDataSlot;
    }
    if (!strcmp(name, "vkSetPrivateData")) {
        return (void*)dynCheck_entry_vkSetPrivateData;
    }
    if (!strcmp(name, "vkGetPrivateData")) {
        return (void*)dynCheck_entry_vkGetPrivateData;
    }
    if (!strcmp(name, "vkCmdSetEvent2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetEvent2 : nullptr;
    }
    if (!strcmp(name, "vkCmdResetEvent2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdResetEvent2 : nullptr;
    }
    if (!strcmp(name, "vkCmdWaitEvents2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdWaitEvents2 : nullptr;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdPipelineBarrier2 : nullptr;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdWriteTimestamp2 : nullptr;
    }
    if (!strcmp(name, "vkQueueSubmit2")) {
        return has1_3OrHigher ? (void*)entry_vkQueueSubmit2 : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyBuffer2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdCopyBuffer2 : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImage2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdCopyImage2 : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdCopyBufferToImage2 : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdCopyImageToBuffer2 : nullptr;
    }
    if (!strcmp(name, "vkCmdBlitImage2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdBlitImage2 : nullptr;
    }
    if (!strcmp(name, "vkCmdResolveImage2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdResolveImage2 : nullptr;
    }
    if (!strcmp(name, "vkCmdBeginRendering")) {
        return has1_3OrHigher ? (void*)entry_vkCmdBeginRendering : nullptr;
    }
    if (!strcmp(name, "vkCmdEndRendering")) {
        return has1_3OrHigher ? (void*)entry_vkCmdEndRendering : nullptr;
    }
    if (!strcmp(name, "vkCmdSetCullMode")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetCullMode : nullptr;
    }
    if (!strcmp(name, "vkCmdSetFrontFace")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetFrontFace : nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveTopology : nullptr;
    }
    if (!strcmp(name, "vkCmdSetViewportWithCount")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetViewportWithCount : nullptr;
    }
    if (!strcmp(name, "vkCmdSetScissorWithCount")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetScissorWithCount : nullptr;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdBindVertexBuffers2 : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthTestEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthWriteEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthCompareOp : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBoundsTestEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetStencilTestEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilOp")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetStencilOp : nullptr;
    }
    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetRasterizerDiscardEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBiasEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveRestartEnable : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
        return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirements;
    }
    if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
        return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirements;
    }
    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
        return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirements;
    }
#endif
#ifdef VK_KHR_swapchain
    if (!strcmp(name, "vkCreateSwapchainKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCreateSwapchainKHR;
    }
    if (!strcmp(name, "vkDestroySwapchainKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkDestroySwapchainKHR;
    }
    if (!strcmp(name, "vkGetSwapchainImagesKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetSwapchainImagesKHR;
    }
    if (!strcmp(name, "vkAcquireNextImageKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkAcquireNextImageKHR;
    }
    if (!strcmp(name, "vkQueuePresentKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)entry_vkQueuePresentKHR;
    }
    if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetDeviceGroupPresentCapabilitiesKHR;
    }
    if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetDeviceGroupSurfacePresentModesKHR;
    }
    if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR;
    }
    if (!strcmp(name, "vkAcquireNextImage2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkAcquireNextImage2KHR;
    }
#endif
#ifdef VK_KHR_android_surface
    if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_android_surface");
        return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
    }
#endif
#ifdef VK_KHR_dynamic_rendering
    if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdBeginRenderingKHR;
    }
    if (!strcmp(name, "vkCmdEndRenderingKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdEndRenderingKHR;
    }
#endif
#ifdef VK_KHR_get_physical_device_properties2
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
    }
#endif
#ifdef VK_KHR_maintenance1
    if (!strcmp(name, "vkTrimCommandPoolKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkTrimCommandPoolKHR;
    }
#endif
#ifdef VK_KHR_external_memory_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_external_memory_capabilities");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
    }
#endif
#ifdef VK_KHR_external_semaphore_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_capabilities");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
    }
#endif
#ifdef VK_KHR_external_semaphore_fd
    if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkImportSemaphoreFdKHR;
    }
    if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetSemaphoreFdKHR;
    }
#endif
#ifdef VK_KHR_descriptor_update_template
    if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR;
    }
    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR;
    }
#endif
#ifdef VK_KHR_create_renderpass2
    if (!strcmp(name, "vkCreateRenderPass2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCreateRenderPass2KHR;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdBeginRenderPass2KHR;
    }
    if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdNextSubpass2KHR;
    }
    if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdEndRenderPass2KHR;
    }
#endif
#ifdef VK_KHR_external_fence_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
        bool hasExt =
            resources->hasInstanceExtension(instance, "VK_KHR_external_fence_capabilities");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
    }
#endif
#ifdef VK_KHR_external_fence_fd
    if (!strcmp(name, "vkImportFenceFdKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkImportFenceFdKHR;
    }
    if (!strcmp(name, "vkGetFenceFdKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetFenceFdKHR;
    }
#endif
#ifdef VK_KHR_get_memory_requirements2
    if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetImageMemoryRequirements2KHR;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2KHR;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR;
    }
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
    if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversionKHR;
    }
    if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversionKHR;
    }
#endif
#ifdef VK_KHR_bind_memory2
    if (!strcmp(name, "vkBindBufferMemory2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkBindBufferMemory2KHR;
    }
    if (!strcmp(name, "vkBindImageMemory2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkBindImageMemory2KHR;
    }
#endif
#ifdef VK_KHR_maintenance3
    if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR;
    }
#endif
#ifdef VK_KHR_buffer_device_address
    if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetBufferDeviceAddressKHR;
    }
    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetBufferOpaqueCaptureAddressKHR;
    }
    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR;
    }
#endif
#ifdef VK_KHR_pipeline_executable_properties
    if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetPipelineExecutablePropertiesKHR;
    }
    if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetPipelineExecutableStatisticsKHR;
    }
    if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetPipelineExecutableInternalRepresentationsKHR;
    }
#endif
#ifdef VK_KHR_synchronization2
    if (!strcmp(name, "vkCmdSetEvent2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetEvent2KHR;
    }
    if (!strcmp(name, "vkCmdResetEvent2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdResetEvent2KHR;
    }
    if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdWaitEvents2KHR;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdPipelineBarrier2KHR;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdWriteTimestamp2KHR;
    }
    if (!strcmp(name, "vkQueueSubmit2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)entry_vkQueueSubmit2KHR;
    }
    if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdWriteBufferMarker2AMD;
    }
    if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)entry_vkGetQueueCheckpointData2NV;
    }
#endif
#ifdef VK_KHR_copy_commands2
    if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdCopyBuffer2KHR;
    }
    if (!strcmp(name, "vkCmdCopyImage2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdCopyImage2KHR;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdCopyBufferToImage2KHR;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdCopyImageToBuffer2KHR;
    }
    if (!strcmp(name, "vkCmdBlitImage2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdBlitImage2KHR;
    }
    if (!strcmp(name, "vkCmdResolveImage2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdResolveImage2KHR;
    }
#endif
#ifdef VK_KHR_maintenance4
    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetDeviceBufferMemoryRequirementsKHR;
    }
    if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetDeviceImageMemoryRequirementsKHR;
    }
    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetDeviceImageSparseMemoryRequirementsKHR;
    }
#endif
#ifdef VK_KHR_maintenance5
    if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdBindIndexBuffer2KHR;
    }
    if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetRenderingAreaGranularityKHR;
    }
    if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetDeviceImageSubresourceLayoutKHR;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetImageSubresourceLayout2KHR;
    }
#endif
#ifdef VK_ANDROID_native_buffer
    if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetSwapchainGrallocUsageANDROID;
    }
    if (!strcmp(name, "vkAcquireImageANDROID")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkAcquireImageANDROID;
    }
    if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)entry_vkQueueSignalReleaseImageANDROID;
    }
    if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetSwapchainGrallocUsage2ANDROID;
    }
#endif
#ifdef VK_EXT_transform_feedback
    if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdBindTransformFeedbackBuffersEXT;
    }
    if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdBeginTransformFeedbackEXT;
    }
    if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdEndTransformFeedbackEXT;
    }
    if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdBeginQueryIndexedEXT;
    }
    if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdEndQueryIndexedEXT;
    }
    if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdDrawIndirectByteCountEXT;
    }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
    if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID;
    }
    if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID;
    }
#endif
#ifdef VK_EXT_tooling_info
    if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT;
    }
#endif
#ifdef VK_EXT_line_rasterization
    if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetLineStippleEXT;
    }
#endif
#ifdef VK_EXT_extended_dynamic_state
    if (!strcmp(name, "vkCmdSetCullModeEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetCullModeEXT;
    }
    if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetFrontFaceEXT;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetPrimitiveTopologyEXT;
    }
    if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetViewportWithCountEXT;
    }
    if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetScissorWithCountEXT;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdBindVertexBuffers2EXT;
    }
    if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetDepthTestEnableEXT;
    }
    if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetDepthWriteEnableEXT;
    }
    if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetDepthCompareOpEXT;
    }
    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetDepthBoundsTestEnableEXT;
    }
    if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetStencilTestEnableEXT;
    }
    if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetStencilOpEXT;
    }
#endif
#ifdef VK_EXT_host_image_copy
    if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCopyMemoryToImageEXT;
    }
    if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCopyImageToMemoryEXT;
    }
    if (!strcmp(name, "vkCopyImageToImageEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCopyImageToImageEXT;
    }
    if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkTransitionImageLayoutEXT;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetImageSubresourceLayout2EXT;
    }
#endif
#ifdef VK_EXT_swapchain_maintenance1
    if (!strcmp(name, "vkReleaseSwapchainImagesEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkReleaseSwapchainImagesEXT;
    }
#endif
#ifdef VK_EXT_private_data
    if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCreatePrivateDataSlotEXT;
    }
    if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkDestroyPrivateDataSlotEXT;
    }
    if (!strcmp(name, "vkSetPrivateDataEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkSetPrivateDataEXT;
    }
    if (!strcmp(name, "vkGetPrivateDataEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkGetPrivateDataEXT;
    }
#endif
#ifdef VK_EXT_extended_dynamic_state2
    if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetPatchControlPointsEXT;
    }
    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetRasterizerDiscardEnableEXT;
    }
    if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetDepthBiasEnableEXT;
    }
    if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetLogicOpEXT;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
        // TODO(b/236246382): Check support for device extension;
        return (void*)dynCheck_entry_vkCmdSetPrimitiveRestartEnableEXT;
    }
#endif
#ifdef VK_GOOGLE_gfxstream
    if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE
                      : nullptr;
    }
    if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkFreeMemorySyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayoutGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkGetLinearImageLayout2GOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkGetBlobGOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkGetBlobGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE
                      : nullptr;
    }
    if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueSubmitAsync2GOOGLE : nullptr;
    }
#endif
    return nullptr;
}
void* goldfish_vulkan_get_device_proc_address(VkDevice device, const char* name) {
    auto resources = ResourceTracker::get();
    bool has1_1OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_1;
    bool has1_2OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_2;
    bool has1_3OrHigher = resources->getApiVersionFromDevice(device) >= VK_API_VERSION_1_3;
#ifdef VK_VERSION_1_0
    if (!strcmp(name, "vkCreateInstance")) {
        return (void*)entry_vkCreateInstance;
    }
    if (!strcmp(name, "vkDestroyInstance")) {
        return (void*)entry_vkDestroyInstance;
    }
    if (!strcmp(name, "vkEnumeratePhysicalDevices")) {
        return (void*)entry_vkEnumeratePhysicalDevices;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures")) {
        return (void*)entry_vkGetPhysicalDeviceFeatures;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceFormatProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceImageFormatProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties")) {
        return (void*)entry_vkGetPhysicalDeviceProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties")) {
        return (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) {
        return (void*)entry_vkGetPhysicalDeviceMemoryProperties;
    }
    if (!strcmp(name, "vkGetInstanceProcAddr")) {
        return (void*)entry_vkGetInstanceProcAddr;
    }
    if (!strcmp(name, "vkGetDeviceProcAddr")) {
        return (void*)entry_vkGetDeviceProcAddr;
    }
    if (!strcmp(name, "vkCreateDevice")) {
        return (void*)entry_vkCreateDevice;
    }
    if (!strcmp(name, "vkDestroyDevice")) {
        return (void*)entry_vkDestroyDevice;
    }
    if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) {
        return (void*)entry_vkEnumerateInstanceExtensionProperties;
    }
    if (!strcmp(name, "vkEnumerateDeviceExtensionProperties")) {
        return (void*)entry_vkEnumerateDeviceExtensionProperties;
    }
    if (!strcmp(name, "vkEnumerateInstanceLayerProperties")) {
        return (void*)entry_vkEnumerateInstanceLayerProperties;
    }
    if (!strcmp(name, "vkEnumerateDeviceLayerProperties")) {
        return (void*)entry_vkEnumerateDeviceLayerProperties;
    }
    if (!strcmp(name, "vkGetDeviceQueue")) {
        return (void*)entry_vkGetDeviceQueue;
    }
    if (!strcmp(name, "vkQueueSubmit")) {
        return (void*)entry_vkQueueSubmit;
    }
    if (!strcmp(name, "vkQueueWaitIdle")) {
        return (void*)entry_vkQueueWaitIdle;
    }
    if (!strcmp(name, "vkDeviceWaitIdle")) {
        return (void*)entry_vkDeviceWaitIdle;
    }
    if (!strcmp(name, "vkAllocateMemory")) {
        return (void*)entry_vkAllocateMemory;
    }
    if (!strcmp(name, "vkFreeMemory")) {
        return (void*)entry_vkFreeMemory;
    }
    if (!strcmp(name, "vkMapMemory")) {
        return (void*)entry_vkMapMemory;
    }
    if (!strcmp(name, "vkUnmapMemory")) {
        return (void*)entry_vkUnmapMemory;
    }
    if (!strcmp(name, "vkFlushMappedMemoryRanges")) {
        return (void*)entry_vkFlushMappedMemoryRanges;
    }
    if (!strcmp(name, "vkInvalidateMappedMemoryRanges")) {
        return (void*)entry_vkInvalidateMappedMemoryRanges;
    }
    if (!strcmp(name, "vkGetDeviceMemoryCommitment")) {
        return (void*)entry_vkGetDeviceMemoryCommitment;
    }
    if (!strcmp(name, "vkBindBufferMemory")) {
        return (void*)entry_vkBindBufferMemory;
    }
    if (!strcmp(name, "vkBindImageMemory")) {
        return (void*)entry_vkBindImageMemory;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements")) {
        return (void*)entry_vkGetBufferMemoryRequirements;
    }
    if (!strcmp(name, "vkGetImageMemoryRequirements")) {
        return (void*)entry_vkGetImageMemoryRequirements;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements")) {
        return (void*)entry_vkGetImageSparseMemoryRequirements;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties")) {
        return (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties;
    }
    if (!strcmp(name, "vkQueueBindSparse")) {
        return (void*)entry_vkQueueBindSparse;
    }
    if (!strcmp(name, "vkCreateFence")) {
        return (void*)entry_vkCreateFence;
    }
    if (!strcmp(name, "vkDestroyFence")) {
        return (void*)entry_vkDestroyFence;
    }
    if (!strcmp(name, "vkResetFences")) {
        return (void*)entry_vkResetFences;
    }
    if (!strcmp(name, "vkGetFenceStatus")) {
        return (void*)entry_vkGetFenceStatus;
    }
    if (!strcmp(name, "vkWaitForFences")) {
        return (void*)entry_vkWaitForFences;
    }
    if (!strcmp(name, "vkCreateSemaphore")) {
        return (void*)entry_vkCreateSemaphore;
    }
    if (!strcmp(name, "vkDestroySemaphore")) {
        return (void*)entry_vkDestroySemaphore;
    }
    if (!strcmp(name, "vkCreateEvent")) {
        return (void*)entry_vkCreateEvent;
    }
    if (!strcmp(name, "vkDestroyEvent")) {
        return (void*)entry_vkDestroyEvent;
    }
    if (!strcmp(name, "vkGetEventStatus")) {
        return (void*)entry_vkGetEventStatus;
    }
    if (!strcmp(name, "vkSetEvent")) {
        return (void*)entry_vkSetEvent;
    }
    if (!strcmp(name, "vkResetEvent")) {
        return (void*)entry_vkResetEvent;
    }
    if (!strcmp(name, "vkCreateQueryPool")) {
        return (void*)entry_vkCreateQueryPool;
    }
    if (!strcmp(name, "vkDestroyQueryPool")) {
        return (void*)entry_vkDestroyQueryPool;
    }
    if (!strcmp(name, "vkGetQueryPoolResults")) {
        return (void*)entry_vkGetQueryPoolResults;
    }
    if (!strcmp(name, "vkCreateBuffer")) {
        return (void*)entry_vkCreateBuffer;
    }
    if (!strcmp(name, "vkDestroyBuffer")) {
        return (void*)entry_vkDestroyBuffer;
    }
    if (!strcmp(name, "vkCreateBufferView")) {
        return (void*)entry_vkCreateBufferView;
    }
    if (!strcmp(name, "vkDestroyBufferView")) {
        return (void*)entry_vkDestroyBufferView;
    }
    if (!strcmp(name, "vkCreateImage")) {
        return (void*)entry_vkCreateImage;
    }
    if (!strcmp(name, "vkDestroyImage")) {
        return (void*)entry_vkDestroyImage;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout")) {
        return (void*)entry_vkGetImageSubresourceLayout;
    }
    if (!strcmp(name, "vkCreateImageView")) {
        return (void*)entry_vkCreateImageView;
    }
    if (!strcmp(name, "vkDestroyImageView")) {
        return (void*)entry_vkDestroyImageView;
    }
    if (!strcmp(name, "vkCreateShaderModule")) {
        return (void*)entry_vkCreateShaderModule;
    }
    if (!strcmp(name, "vkDestroyShaderModule")) {
        return (void*)entry_vkDestroyShaderModule;
    }
    if (!strcmp(name, "vkCreatePipelineCache")) {
        return (void*)entry_vkCreatePipelineCache;
    }
    if (!strcmp(name, "vkDestroyPipelineCache")) {
        return (void*)entry_vkDestroyPipelineCache;
    }
    if (!strcmp(name, "vkGetPipelineCacheData")) {
        return (void*)entry_vkGetPipelineCacheData;
    }
    if (!strcmp(name, "vkMergePipelineCaches")) {
        return (void*)entry_vkMergePipelineCaches;
    }
    if (!strcmp(name, "vkCreateGraphicsPipelines")) {
        return (void*)entry_vkCreateGraphicsPipelines;
    }
    if (!strcmp(name, "vkCreateComputePipelines")) {
        return (void*)entry_vkCreateComputePipelines;
    }
    if (!strcmp(name, "vkDestroyPipeline")) {
        return (void*)entry_vkDestroyPipeline;
    }
    if (!strcmp(name, "vkCreatePipelineLayout")) {
        return (void*)entry_vkCreatePipelineLayout;
    }
    if (!strcmp(name, "vkDestroyPipelineLayout")) {
        return (void*)entry_vkDestroyPipelineLayout;
    }
    if (!strcmp(name, "vkCreateSampler")) {
        return (void*)entry_vkCreateSampler;
    }
    if (!strcmp(name, "vkDestroySampler")) {
        return (void*)entry_vkDestroySampler;
    }
    if (!strcmp(name, "vkCreateDescriptorSetLayout")) {
        return (void*)entry_vkCreateDescriptorSetLayout;
    }
    if (!strcmp(name, "vkDestroyDescriptorSetLayout")) {
        return (void*)entry_vkDestroyDescriptorSetLayout;
    }
    if (!strcmp(name, "vkCreateDescriptorPool")) {
        return (void*)entry_vkCreateDescriptorPool;
    }
    if (!strcmp(name, "vkDestroyDescriptorPool")) {
        return (void*)entry_vkDestroyDescriptorPool;
    }
    if (!strcmp(name, "vkResetDescriptorPool")) {
        return (void*)entry_vkResetDescriptorPool;
    }
    if (!strcmp(name, "vkAllocateDescriptorSets")) {
        return (void*)entry_vkAllocateDescriptorSets;
    }
    if (!strcmp(name, "vkFreeDescriptorSets")) {
        return (void*)entry_vkFreeDescriptorSets;
    }
    if (!strcmp(name, "vkUpdateDescriptorSets")) {
        return (void*)entry_vkUpdateDescriptorSets;
    }
    if (!strcmp(name, "vkCreateFramebuffer")) {
        return (void*)entry_vkCreateFramebuffer;
    }
    if (!strcmp(name, "vkDestroyFramebuffer")) {
        return (void*)entry_vkDestroyFramebuffer;
    }
    if (!strcmp(name, "vkCreateRenderPass")) {
        return (void*)entry_vkCreateRenderPass;
    }
    if (!strcmp(name, "vkDestroyRenderPass")) {
        return (void*)entry_vkDestroyRenderPass;
    }
    if (!strcmp(name, "vkGetRenderAreaGranularity")) {
        return (void*)entry_vkGetRenderAreaGranularity;
    }
    if (!strcmp(name, "vkCreateCommandPool")) {
        return (void*)entry_vkCreateCommandPool;
    }
    if (!strcmp(name, "vkDestroyCommandPool")) {
        return (void*)entry_vkDestroyCommandPool;
    }
    if (!strcmp(name, "vkResetCommandPool")) {
        return (void*)entry_vkResetCommandPool;
    }
    if (!strcmp(name, "vkAllocateCommandBuffers")) {
        return (void*)entry_vkAllocateCommandBuffers;
    }
    if (!strcmp(name, "vkFreeCommandBuffers")) {
        return (void*)entry_vkFreeCommandBuffers;
    }
    if (!strcmp(name, "vkBeginCommandBuffer")) {
        return (void*)entry_vkBeginCommandBuffer;
    }
    if (!strcmp(name, "vkEndCommandBuffer")) {
        return (void*)entry_vkEndCommandBuffer;
    }
    if (!strcmp(name, "vkResetCommandBuffer")) {
        return (void*)entry_vkResetCommandBuffer;
    }
    if (!strcmp(name, "vkCmdBindPipeline")) {
        return (void*)entry_vkCmdBindPipeline;
    }
    if (!strcmp(name, "vkCmdSetViewport")) {
        return (void*)entry_vkCmdSetViewport;
    }
    if (!strcmp(name, "vkCmdSetScissor")) {
        return (void*)entry_vkCmdSetScissor;
    }
    if (!strcmp(name, "vkCmdSetLineWidth")) {
        return (void*)entry_vkCmdSetLineWidth;
    }
    if (!strcmp(name, "vkCmdSetDepthBias")) {
        return (void*)entry_vkCmdSetDepthBias;
    }
    if (!strcmp(name, "vkCmdSetBlendConstants")) {
        return (void*)entry_vkCmdSetBlendConstants;
    }
    if (!strcmp(name, "vkCmdSetDepthBounds")) {
        return (void*)entry_vkCmdSetDepthBounds;
    }
    if (!strcmp(name, "vkCmdSetStencilCompareMask")) {
        return (void*)entry_vkCmdSetStencilCompareMask;
    }
    if (!strcmp(name, "vkCmdSetStencilWriteMask")) {
        return (void*)entry_vkCmdSetStencilWriteMask;
    }
    if (!strcmp(name, "vkCmdSetStencilReference")) {
        return (void*)entry_vkCmdSetStencilReference;
    }
    if (!strcmp(name, "vkCmdBindDescriptorSets")) {
        return (void*)entry_vkCmdBindDescriptorSets;
    }
    if (!strcmp(name, "vkCmdBindIndexBuffer")) {
        return (void*)entry_vkCmdBindIndexBuffer;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers")) {
        return (void*)entry_vkCmdBindVertexBuffers;
    }
    if (!strcmp(name, "vkCmdDraw")) {
        return (void*)entry_vkCmdDraw;
    }
    if (!strcmp(name, "vkCmdDrawIndexed")) {
        return (void*)entry_vkCmdDrawIndexed;
    }
    if (!strcmp(name, "vkCmdDrawIndirect")) {
        return (void*)entry_vkCmdDrawIndirect;
    }
    if (!strcmp(name, "vkCmdDrawIndexedIndirect")) {
        return (void*)entry_vkCmdDrawIndexedIndirect;
    }
    if (!strcmp(name, "vkCmdDispatch")) {
        return (void*)entry_vkCmdDispatch;
    }
    if (!strcmp(name, "vkCmdDispatchIndirect")) {
        return (void*)entry_vkCmdDispatchIndirect;
    }
    if (!strcmp(name, "vkCmdCopyBuffer")) {
        return (void*)entry_vkCmdCopyBuffer;
    }
    if (!strcmp(name, "vkCmdCopyImage")) {
        return (void*)entry_vkCmdCopyImage;
    }
    if (!strcmp(name, "vkCmdBlitImage")) {
        return (void*)entry_vkCmdBlitImage;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage")) {
        return (void*)entry_vkCmdCopyBufferToImage;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer")) {
        return (void*)entry_vkCmdCopyImageToBuffer;
    }
    if (!strcmp(name, "vkCmdUpdateBuffer")) {
        return (void*)entry_vkCmdUpdateBuffer;
    }
    if (!strcmp(name, "vkCmdFillBuffer")) {
        return (void*)entry_vkCmdFillBuffer;
    }
    if (!strcmp(name, "vkCmdClearColorImage")) {
        return (void*)entry_vkCmdClearColorImage;
    }
    if (!strcmp(name, "vkCmdClearDepthStencilImage")) {
        return (void*)entry_vkCmdClearDepthStencilImage;
    }
    if (!strcmp(name, "vkCmdClearAttachments")) {
        return (void*)entry_vkCmdClearAttachments;
    }
    if (!strcmp(name, "vkCmdResolveImage")) {
        return (void*)entry_vkCmdResolveImage;
    }
    if (!strcmp(name, "vkCmdSetEvent")) {
        return (void*)entry_vkCmdSetEvent;
    }
    if (!strcmp(name, "vkCmdResetEvent")) {
        return (void*)entry_vkCmdResetEvent;
    }
    if (!strcmp(name, "vkCmdWaitEvents")) {
        return (void*)entry_vkCmdWaitEvents;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier")) {
        return (void*)entry_vkCmdPipelineBarrier;
    }
    if (!strcmp(name, "vkCmdBeginQuery")) {
        return (void*)entry_vkCmdBeginQuery;
    }
    if (!strcmp(name, "vkCmdEndQuery")) {
        return (void*)entry_vkCmdEndQuery;
    }
    if (!strcmp(name, "vkCmdResetQueryPool")) {
        return (void*)entry_vkCmdResetQueryPool;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp")) {
        return (void*)entry_vkCmdWriteTimestamp;
    }
    if (!strcmp(name, "vkCmdCopyQueryPoolResults")) {
        return (void*)entry_vkCmdCopyQueryPoolResults;
    }
    if (!strcmp(name, "vkCmdPushConstants")) {
        return (void*)entry_vkCmdPushConstants;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass")) {
        return (void*)entry_vkCmdBeginRenderPass;
    }
    if (!strcmp(name, "vkCmdNextSubpass")) {
        return (void*)entry_vkCmdNextSubpass;
    }
    if (!strcmp(name, "vkCmdEndRenderPass")) {
        return (void*)entry_vkCmdEndRenderPass;
    }
    if (!strcmp(name, "vkCmdExecuteCommands")) {
        return (void*)entry_vkCmdExecuteCommands;
    }
#endif
#ifdef VK_VERSION_1_1
    if (!strcmp(name, "vkEnumerateInstanceVersion")) {
        return has1_1OrHigher ? (void*)entry_vkEnumerateInstanceVersion : nullptr;
    }
    if (!strcmp(name, "vkBindBufferMemory2")) {
        return has1_1OrHigher ? (void*)entry_vkBindBufferMemory2 : nullptr;
    }
    if (!strcmp(name, "vkBindImageMemory2")) {
        return has1_1OrHigher ? (void*)entry_vkBindImageMemory2 : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures")) {
        return has1_1OrHigher ? (void*)entry_vkGetDeviceGroupPeerMemoryFeatures : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDeviceMask")) {
        return has1_1OrHigher ? (void*)entry_vkCmdSetDeviceMask : nullptr;
    }
    if (!strcmp(name, "vkCmdDispatchBase")) {
        return has1_1OrHigher ? (void*)entry_vkCmdDispatchBase : nullptr;
    }
    if (!strcmp(name, "vkEnumeratePhysicalDeviceGroups")) {
        return nullptr;
    }
    if (!strcmp(name, "vkGetImageMemoryRequirements2")) {
        return has1_1OrHigher ? (void*)entry_vkGetImageMemoryRequirements2 : nullptr;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements2")) {
        return has1_1OrHigher ? (void*)entry_vkGetBufferMemoryRequirements2 : nullptr;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2")) {
        return has1_1OrHigher ? (void*)entry_vkGetImageSparseMemoryRequirements2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFeatures2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceFormatProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2 : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2
                              : nullptr;
    }
    if (!strcmp(name, "vkTrimCommandPool")) {
        return has1_1OrHigher ? (void*)entry_vkTrimCommandPool : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceQueue2")) {
        return has1_1OrHigher ? (void*)entry_vkGetDeviceQueue2 : nullptr;
    }
    if (!strcmp(name, "vkCreateSamplerYcbcrConversion")) {
        return has1_1OrHigher ? (void*)entry_vkCreateSamplerYcbcrConversion : nullptr;
    }
    if (!strcmp(name, "vkDestroySamplerYcbcrConversion")) {
        return has1_1OrHigher ? (void*)entry_vkDestroySamplerYcbcrConversion : nullptr;
    }
    if (!strcmp(name, "vkCreateDescriptorUpdateTemplate")) {
        return has1_1OrHigher ? (void*)entry_vkCreateDescriptorUpdateTemplate : nullptr;
    }
    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate")) {
        return has1_1OrHigher ? (void*)entry_vkDestroyDescriptorUpdateTemplate : nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate")) {
        return has1_1OrHigher ? (void*)entry_vkUpdateDescriptorSetWithTemplate : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalBufferProperties : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalFenceProperties")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalFenceProperties : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphoreProperties")) {
        return has1_1OrHigher ? (void*)entry_vkGetPhysicalDeviceExternalSemaphoreProperties
                              : nullptr;
    }
    if (!strcmp(name, "vkGetDescriptorSetLayoutSupport")) {
        return has1_1OrHigher ? (void*)entry_vkGetDescriptorSetLayoutSupport : nullptr;
    }
#endif
#ifdef VK_VERSION_1_2
    if (!strcmp(name, "vkCmdDrawIndirectCount")) {
        return has1_2OrHigher ? (void*)entry_vkCmdDrawIndirectCount : nullptr;
    }
    if (!strcmp(name, "vkCmdDrawIndexedIndirectCount")) {
        return has1_2OrHigher ? (void*)entry_vkCmdDrawIndexedIndirectCount : nullptr;
    }
    if (!strcmp(name, "vkCreateRenderPass2")) {
        return has1_2OrHigher ? (void*)entry_vkCreateRenderPass2 : nullptr;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass2")) {
        return has1_2OrHigher ? (void*)entry_vkCmdBeginRenderPass2 : nullptr;
    }
    if (!strcmp(name, "vkCmdNextSubpass2")) {
        return has1_2OrHigher ? (void*)entry_vkCmdNextSubpass2 : nullptr;
    }
    if (!strcmp(name, "vkCmdEndRenderPass2")) {
        return has1_2OrHigher ? (void*)entry_vkCmdEndRenderPass2 : nullptr;
    }
    if (!strcmp(name, "vkResetQueryPool")) {
        return has1_2OrHigher ? (void*)entry_vkResetQueryPool : nullptr;
    }
    if (!strcmp(name, "vkGetSemaphoreCounterValue")) {
        return has1_2OrHigher ? (void*)entry_vkGetSemaphoreCounterValue : nullptr;
    }
    if (!strcmp(name, "vkWaitSemaphores")) {
        return has1_2OrHigher ? (void*)entry_vkWaitSemaphores : nullptr;
    }
    if (!strcmp(name, "vkSignalSemaphore")) {
        return has1_2OrHigher ? (void*)entry_vkSignalSemaphore : nullptr;
    }
    if (!strcmp(name, "vkGetBufferDeviceAddress")) {
        return has1_2OrHigher ? (void*)entry_vkGetBufferDeviceAddress : nullptr;
    }
    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddress")) {
        return has1_2OrHigher ? (void*)entry_vkGetBufferOpaqueCaptureAddress : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddress")) {
        return has1_2OrHigher ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddress : nullptr;
    }
#endif
#ifdef VK_VERSION_1_3
    if (!strcmp(name, "vkGetPhysicalDeviceToolProperties")) {
        return has1_3OrHigher ? (void*)entry_vkGetPhysicalDeviceToolProperties : nullptr;
    }
    if (!strcmp(name, "vkCreatePrivateDataSlot")) {
        return has1_3OrHigher ? (void*)entry_vkCreatePrivateDataSlot : nullptr;
    }
    if (!strcmp(name, "vkDestroyPrivateDataSlot")) {
        return has1_3OrHigher ? (void*)entry_vkDestroyPrivateDataSlot : nullptr;
    }
    if (!strcmp(name, "vkSetPrivateData")) {
        return has1_3OrHigher ? (void*)entry_vkSetPrivateData : nullptr;
    }
    if (!strcmp(name, "vkGetPrivateData")) {
        return has1_3OrHigher ? (void*)entry_vkGetPrivateData : nullptr;
    }
    if (!strcmp(name, "vkCmdSetEvent2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetEvent2 : nullptr;
    }
    if (!strcmp(name, "vkCmdResetEvent2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdResetEvent2 : nullptr;
    }
    if (!strcmp(name, "vkCmdWaitEvents2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdWaitEvents2 : nullptr;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdPipelineBarrier2 : nullptr;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdWriteTimestamp2 : nullptr;
    }
    if (!strcmp(name, "vkQueueSubmit2")) {
        return has1_3OrHigher ? (void*)entry_vkQueueSubmit2 : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyBuffer2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdCopyBuffer2 : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImage2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdCopyImage2 : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdCopyBufferToImage2 : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdCopyImageToBuffer2 : nullptr;
    }
    if (!strcmp(name, "vkCmdBlitImage2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdBlitImage2 : nullptr;
    }
    if (!strcmp(name, "vkCmdResolveImage2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdResolveImage2 : nullptr;
    }
    if (!strcmp(name, "vkCmdBeginRendering")) {
        return has1_3OrHigher ? (void*)entry_vkCmdBeginRendering : nullptr;
    }
    if (!strcmp(name, "vkCmdEndRendering")) {
        return has1_3OrHigher ? (void*)entry_vkCmdEndRendering : nullptr;
    }
    if (!strcmp(name, "vkCmdSetCullMode")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetCullMode : nullptr;
    }
    if (!strcmp(name, "vkCmdSetFrontFace")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetFrontFace : nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveTopology")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveTopology : nullptr;
    }
    if (!strcmp(name, "vkCmdSetViewportWithCount")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetViewportWithCount : nullptr;
    }
    if (!strcmp(name, "vkCmdSetScissorWithCount")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetScissorWithCount : nullptr;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers2")) {
        return has1_3OrHigher ? (void*)entry_vkCmdBindVertexBuffers2 : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthTestEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthTestEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthWriteEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthWriteEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthCompareOp")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthCompareOp : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBoundsTestEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilTestEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetStencilTestEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilOp")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetStencilOp : nullptr;
    }
    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetRasterizerDiscardEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBiasEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetDepthBiasEnable : nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnable")) {
        return has1_3OrHigher ? (void*)entry_vkCmdSetPrimitiveRestartEnable : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirements")) {
        return has1_3OrHigher ? (void*)entry_vkGetDeviceBufferMemoryRequirements : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageMemoryRequirements")) {
        return has1_3OrHigher ? (void*)entry_vkGetDeviceImageMemoryRequirements : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirements")) {
        return has1_3OrHigher ? (void*)entry_vkGetDeviceImageSparseMemoryRequirements : nullptr;
    }
#endif
#ifdef VK_KHR_swapchain
    if (!strcmp(name, "vkCreateSwapchainKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkCreateSwapchainKHR : nullptr;
    }
    if (!strcmp(name, "vkDestroySwapchainKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkDestroySwapchainKHR : nullptr;
    }
    if (!strcmp(name, "vkGetSwapchainImagesKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkGetSwapchainImagesKHR : nullptr;
    }
    if (!strcmp(name, "vkAcquireNextImageKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkAcquireNextImageKHR : nullptr;
    }
    if (!strcmp(name, "vkQueuePresentKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkQueuePresentKHR : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkGetDeviceGroupPresentCapabilitiesKHR : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkGetDeviceGroupSurfacePresentModesKHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkGetPhysicalDevicePresentRectanglesKHR : nullptr;
    }
    if (!strcmp(name, "vkAcquireNextImage2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_swapchain");
        return hasExt ? (void*)entry_vkAcquireNextImage2KHR : nullptr;
    }
#endif
#ifdef VK_KHR_android_surface
    if (!strcmp(name, "vkCreateAndroidSurfaceKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_android_surface");
        return hasExt ? (void*)entry_vkCreateAndroidSurfaceKHR : nullptr;
    }
#endif
#ifdef VK_KHR_dynamic_rendering
    if (!strcmp(name, "vkCmdBeginRenderingKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
        return hasExt ? (void*)entry_vkCmdBeginRenderingKHR : nullptr;
    }
    if (!strcmp(name, "vkCmdEndRenderingKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_dynamic_rendering");
        return hasExt ? (void*)entry_vkCmdEndRenderingKHR : nullptr;
    }
#endif
#ifdef VK_KHR_get_physical_device_properties2
    if (!strcmp(name, "vkGetPhysicalDeviceFeatures2KHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceFeatures2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceProperties2KHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceFormatProperties2KHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceFormatProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceImageFormatProperties2KHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceImageFormatProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceQueueFamilyProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceMemoryProperties2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_get_physical_device_properties2");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceSparseImageFormatProperties2KHR : nullptr;
    }
#endif
#ifdef VK_KHR_maintenance1
    if (!strcmp(name, "vkTrimCommandPoolKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance1");
        return hasExt ? (void*)entry_vkTrimCommandPoolKHR : nullptr;
    }
#endif
#ifdef VK_KHR_external_memory_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_memory_capabilities");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalBufferPropertiesKHR : nullptr;
    }
#endif
#ifdef VK_KHR_external_semaphore_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_capabilities");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR : nullptr;
    }
#endif
#ifdef VK_KHR_external_semaphore_fd
    if (!strcmp(name, "vkImportSemaphoreFdKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
        return hasExt ? (void*)entry_vkImportSemaphoreFdKHR : nullptr;
    }
    if (!strcmp(name, "vkGetSemaphoreFdKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_fd");
        return hasExt ? (void*)entry_vkGetSemaphoreFdKHR : nullptr;
    }
#endif
#ifdef VK_KHR_descriptor_update_template
    if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
        return hasExt ? (void*)entry_vkCreateDescriptorUpdateTemplateKHR : nullptr;
    }
    if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
        return hasExt ? (void*)entry_vkDestroyDescriptorUpdateTemplateKHR : nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_descriptor_update_template");
        return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateKHR : nullptr;
    }
#endif
#ifdef VK_KHR_create_renderpass2
    if (!strcmp(name, "vkCreateRenderPass2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
        return hasExt ? (void*)entry_vkCreateRenderPass2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdBeginRenderPass2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
        return hasExt ? (void*)entry_vkCmdBeginRenderPass2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdNextSubpass2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
        return hasExt ? (void*)entry_vkCmdNextSubpass2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdEndRenderPass2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_create_renderpass2");
        return hasExt ? (void*)entry_vkCmdEndRenderPass2KHR : nullptr;
    }
#endif
#ifdef VK_KHR_external_fence_capabilities
    if (!strcmp(name, "vkGetPhysicalDeviceExternalFencePropertiesKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_capabilities");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceExternalFencePropertiesKHR : nullptr;
    }
#endif
#ifdef VK_KHR_external_fence_fd
    if (!strcmp(name, "vkImportFenceFdKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
        return hasExt ? (void*)entry_vkImportFenceFdKHR : nullptr;
    }
    if (!strcmp(name, "vkGetFenceFdKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_external_fence_fd");
        return hasExt ? (void*)entry_vkGetFenceFdKHR : nullptr;
    }
#endif
#ifdef VK_KHR_get_memory_requirements2
    if (!strcmp(name, "vkGetImageMemoryRequirements2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
        return hasExt ? (void*)entry_vkGetImageMemoryRequirements2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
        return hasExt ? (void*)entry_vkGetBufferMemoryRequirements2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_get_memory_requirements2");
        return hasExt ? (void*)entry_vkGetImageSparseMemoryRequirements2KHR : nullptr;
    }
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
    if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
        return hasExt ? (void*)entry_vkCreateSamplerYcbcrConversionKHR : nullptr;
    }
    if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_sampler_ycbcr_conversion");
        return hasExt ? (void*)entry_vkDestroySamplerYcbcrConversionKHR : nullptr;
    }
#endif
#ifdef VK_KHR_bind_memory2
    if (!strcmp(name, "vkBindBufferMemory2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
        return hasExt ? (void*)entry_vkBindBufferMemory2KHR : nullptr;
    }
    if (!strcmp(name, "vkBindImageMemory2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_bind_memory2");
        return hasExt ? (void*)entry_vkBindImageMemory2KHR : nullptr;
    }
#endif
#ifdef VK_KHR_maintenance3
    if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance3");
        return hasExt ? (void*)entry_vkGetDescriptorSetLayoutSupportKHR : nullptr;
    }
#endif
#ifdef VK_KHR_buffer_device_address
    if (!strcmp(name, "vkGetBufferDeviceAddressKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
        return hasExt ? (void*)entry_vkGetBufferDeviceAddressKHR : nullptr;
    }
    if (!strcmp(name, "vkGetBufferOpaqueCaptureAddressKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
        return hasExt ? (void*)entry_vkGetBufferOpaqueCaptureAddressKHR : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_buffer_device_address");
        return hasExt ? (void*)entry_vkGetDeviceMemoryOpaqueCaptureAddressKHR : nullptr;
    }
#endif
#ifdef VK_KHR_pipeline_executable_properties
    if (!strcmp(name, "vkGetPipelineExecutablePropertiesKHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
        return hasExt ? (void*)entry_vkGetPipelineExecutablePropertiesKHR : nullptr;
    }
    if (!strcmp(name, "vkGetPipelineExecutableStatisticsKHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
        return hasExt ? (void*)entry_vkGetPipelineExecutableStatisticsKHR : nullptr;
    }
    if (!strcmp(name, "vkGetPipelineExecutableInternalRepresentationsKHR")) {
        bool hasExt =
            resources->hasDeviceExtension(device, "VK_KHR_pipeline_executable_properties");
        return hasExt ? (void*)entry_vkGetPipelineExecutableInternalRepresentationsKHR : nullptr;
    }
#endif
#ifdef VK_KHR_synchronization2
    if (!strcmp(name, "vkCmdSetEvent2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
        return hasExt ? (void*)entry_vkCmdSetEvent2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdResetEvent2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
        return hasExt ? (void*)entry_vkCmdResetEvent2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdWaitEvents2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
        return hasExt ? (void*)entry_vkCmdWaitEvents2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdPipelineBarrier2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
        return hasExt ? (void*)entry_vkCmdPipelineBarrier2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdWriteTimestamp2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
        return hasExt ? (void*)entry_vkCmdWriteTimestamp2KHR : nullptr;
    }
    if (!strcmp(name, "vkQueueSubmit2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
        return hasExt ? (void*)entry_vkQueueSubmit2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdWriteBufferMarker2AMD")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
        return hasExt ? (void*)entry_vkCmdWriteBufferMarker2AMD : nullptr;
    }
    if (!strcmp(name, "vkGetQueueCheckpointData2NV")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_synchronization2");
        return hasExt ? (void*)entry_vkGetQueueCheckpointData2NV : nullptr;
    }
#endif
#ifdef VK_KHR_copy_commands2
    if (!strcmp(name, "vkCmdCopyBuffer2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
        return hasExt ? (void*)entry_vkCmdCopyBuffer2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImage2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
        return hasExt ? (void*)entry_vkCmdCopyImage2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyBufferToImage2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
        return hasExt ? (void*)entry_vkCmdCopyBufferToImage2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdCopyImageToBuffer2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
        return hasExt ? (void*)entry_vkCmdCopyImageToBuffer2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdBlitImage2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
        return hasExt ? (void*)entry_vkCmdBlitImage2KHR : nullptr;
    }
    if (!strcmp(name, "vkCmdResolveImage2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_copy_commands2");
        return hasExt ? (void*)entry_vkCmdResolveImage2KHR : nullptr;
    }
#endif
#ifdef VK_KHR_maintenance4
    if (!strcmp(name, "vkGetDeviceBufferMemoryRequirementsKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
        return hasExt ? (void*)entry_vkGetDeviceBufferMemoryRequirementsKHR : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageMemoryRequirementsKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
        return hasExt ? (void*)entry_vkGetDeviceImageMemoryRequirementsKHR : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageSparseMemoryRequirementsKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance4");
        return hasExt ? (void*)entry_vkGetDeviceImageSparseMemoryRequirementsKHR : nullptr;
    }
#endif
#ifdef VK_KHR_maintenance5
    if (!strcmp(name, "vkCmdBindIndexBuffer2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
        return hasExt ? (void*)entry_vkCmdBindIndexBuffer2KHR : nullptr;
    }
    if (!strcmp(name, "vkGetRenderingAreaGranularityKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
        return hasExt ? (void*)entry_vkGetRenderingAreaGranularityKHR : nullptr;
    }
    if (!strcmp(name, "vkGetDeviceImageSubresourceLayoutKHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
        return hasExt ? (void*)entry_vkGetDeviceImageSubresourceLayoutKHR : nullptr;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout2KHR")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_KHR_maintenance5");
        return hasExt ? (void*)entry_vkGetImageSubresourceLayout2KHR : nullptr;
    }
#endif
#ifdef VK_ANDROID_native_buffer
    if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
        return hasExt ? (void*)entry_vkGetSwapchainGrallocUsageANDROID : nullptr;
    }
    if (!strcmp(name, "vkAcquireImageANDROID")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
        return hasExt ? (void*)entry_vkAcquireImageANDROID : nullptr;
    }
    if (!strcmp(name, "vkQueueSignalReleaseImageANDROID")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
        return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROID : nullptr;
    }
    if (!strcmp(name, "vkGetSwapchainGrallocUsage2ANDROID")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_ANDROID_native_buffer");
        return hasExt ? (void*)entry_vkGetSwapchainGrallocUsage2ANDROID : nullptr;
    }
#endif
#ifdef VK_EXT_transform_feedback
    if (!strcmp(name, "vkCmdBindTransformFeedbackBuffersEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
        return hasExt ? (void*)entry_vkCmdBindTransformFeedbackBuffersEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdBeginTransformFeedbackEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
        return hasExt ? (void*)entry_vkCmdBeginTransformFeedbackEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdEndTransformFeedbackEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
        return hasExt ? (void*)entry_vkCmdEndTransformFeedbackEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdBeginQueryIndexedEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
        return hasExt ? (void*)entry_vkCmdBeginQueryIndexedEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdEndQueryIndexedEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
        return hasExt ? (void*)entry_vkCmdEndQueryIndexedEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdDrawIndirectByteCountEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_transform_feedback");
        return hasExt ? (void*)entry_vkCmdDrawIndirectByteCountEXT : nullptr;
    }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
    if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID")) {
        bool hasExt = resources->hasDeviceExtension(
            device, "VK_ANDROID_external_memory_android_hardware_buffer");
        return hasExt ? (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID : nullptr;
    }
    if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID")) {
        bool hasExt = resources->hasDeviceExtension(
            device, "VK_ANDROID_external_memory_android_hardware_buffer");
        return hasExt ? (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID : nullptr;
    }
#endif
#ifdef VK_EXT_tooling_info
    if (!strcmp(name, "vkGetPhysicalDeviceToolPropertiesEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_tooling_info");
        return hasExt ? (void*)entry_vkGetPhysicalDeviceToolPropertiesEXT : nullptr;
    }
#endif
#ifdef VK_EXT_line_rasterization
    if (!strcmp(name, "vkCmdSetLineStippleEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_line_rasterization");
        return hasExt ? (void*)entry_vkCmdSetLineStippleEXT : nullptr;
    }
#endif
#ifdef VK_EXT_extended_dynamic_state
    if (!strcmp(name, "vkCmdSetCullModeEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetCullModeEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetFrontFaceEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetFrontFaceEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveTopologyEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetPrimitiveTopologyEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetViewportWithCountEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetViewportWithCountEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetScissorWithCountEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetScissorWithCountEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdBindVertexBuffers2EXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdBindVertexBuffers2EXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthTestEnableEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetDepthTestEnableEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthWriteEnableEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetDepthWriteEnableEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthCompareOpEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetDepthCompareOpEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBoundsTestEnableEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetDepthBoundsTestEnableEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilTestEnableEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetStencilTestEnableEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetStencilOpEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state");
        return hasExt ? (void*)entry_vkCmdSetStencilOpEXT : nullptr;
    }
#endif
#ifdef VK_EXT_host_image_copy
    if (!strcmp(name, "vkCopyMemoryToImageEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
        return hasExt ? (void*)entry_vkCopyMemoryToImageEXT : nullptr;
    }
    if (!strcmp(name, "vkCopyImageToMemoryEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
        return hasExt ? (void*)entry_vkCopyImageToMemoryEXT : nullptr;
    }
    if (!strcmp(name, "vkCopyImageToImageEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
        return hasExt ? (void*)entry_vkCopyImageToImageEXT : nullptr;
    }
    if (!strcmp(name, "vkTransitionImageLayoutEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
        return hasExt ? (void*)entry_vkTransitionImageLayoutEXT : nullptr;
    }
    if (!strcmp(name, "vkGetImageSubresourceLayout2EXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_host_image_copy");
        return hasExt ? (void*)entry_vkGetImageSubresourceLayout2EXT : nullptr;
    }
#endif
#ifdef VK_EXT_swapchain_maintenance1
    if (!strcmp(name, "vkReleaseSwapchainImagesEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_swapchain_maintenance1");
        return hasExt ? (void*)entry_vkReleaseSwapchainImagesEXT : nullptr;
    }
#endif
#ifdef VK_EXT_private_data
    if (!strcmp(name, "vkCreatePrivateDataSlotEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
        return hasExt ? (void*)entry_vkCreatePrivateDataSlotEXT : nullptr;
    }
    if (!strcmp(name, "vkDestroyPrivateDataSlotEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
        return hasExt ? (void*)entry_vkDestroyPrivateDataSlotEXT : nullptr;
    }
    if (!strcmp(name, "vkSetPrivateDataEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
        return hasExt ? (void*)entry_vkSetPrivateDataEXT : nullptr;
    }
    if (!strcmp(name, "vkGetPrivateDataEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_private_data");
        return hasExt ? (void*)entry_vkGetPrivateDataEXT : nullptr;
    }
#endif
#ifdef VK_EXT_extended_dynamic_state2
    if (!strcmp(name, "vkCmdSetPatchControlPointsEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
        return hasExt ? (void*)entry_vkCmdSetPatchControlPointsEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetRasterizerDiscardEnableEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
        return hasExt ? (void*)entry_vkCmdSetRasterizerDiscardEnableEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetDepthBiasEnableEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
        return hasExt ? (void*)entry_vkCmdSetDepthBiasEnableEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetLogicOpEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
        return hasExt ? (void*)entry_vkCmdSetLogicOpEXT : nullptr;
    }
    if (!strcmp(name, "vkCmdSetPrimitiveRestartEnableEXT")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_EXT_extended_dynamic_state2");
        return hasExt ? (void*)entry_vkCmdSetPrimitiveRestartEnableEXT : nullptr;
    }
#endif
#ifdef VK_GOOGLE_gfxstream
    if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkBeginCommandBufferAsyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkBeginCommandBufferAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkEndCommandBufferAsyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkEndCommandBufferAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkResetCommandBufferAsyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkResetCommandBufferAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkCommandBufferHostSyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkCommandBufferHostSyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkGetMemoryHostAddressInfoGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkGetMemoryHostAddressInfoGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkFreeMemorySyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkFreeMemorySyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueHostSyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueHostSyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueSubmitAsyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueSubmitAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueWaitIdleAsyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueWaitIdleAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueBindSparseAsyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueBindSparseAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkGetLinearImageLayoutGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkGetLinearImageLayoutGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkGetLinearImageLayout2GOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkGetLinearImageLayout2GOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueFlushCommandsGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueFlushCommandsGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueCommitDescriptorSetUpdatesGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueCommitDescriptorSetUpdatesGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkCollectDescriptorPoolIdsGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkCollectDescriptorPoolIdsGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueFlushCommandsFromAuxMemoryGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueFlushCommandsFromAuxMemoryGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkGetBlobGOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkGetBlobGOOGLE : nullptr;
    }
    if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSized2GOOGLE : nullptr;
    }
    if (!strcmp(name, "vkQueueSubmitAsync2GOOGLE")) {
        bool hasExt = resources->hasDeviceExtension(device, "VK_GOOGLE_gfxstream");
        return hasExt ? (void*)entry_vkQueueSubmitAsync2GOOGLE : nullptr;
    }
#endif
    return nullptr;
}

}  // namespace vk
}  // namespace gfxstream