diff --git a/system/vulkan/func_table.cpp b/system/vulkan/func_table.cpp
index 2d0b138..c9dd80d 100644
--- a/system/vulkan/func_table.cpp
+++ b/system/vulkan/func_table.cpp
@@ -31,6 +31,8 @@
 
 #include "goldfish_vk_private_defs.h"
 
+#include <log/log.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
@@ -40,6 +42,11 @@
 
 namespace goldfish_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,
@@ -1593,6 +1600,22 @@
     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 = HostConnection::get()->vkEncoder();
+    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,
@@ -1605,6 +1628,22 @@
     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 = HostConnection::get()->vkEncoder();
+    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,
@@ -1616,6 +1655,22 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
 static void entry_vkCmdSetDeviceMask(
     VkCommandBuffer commandBuffer,
     uint32_t deviceMask)
@@ -1660,6 +1715,20 @@
     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 = HostConnection::get()->vkEncoder();
+    resources->on_vkGetImageMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
+}
 static void entry_vkGetBufferMemoryRequirements2(
     VkDevice device,
     const VkBufferMemoryRequirementsInfo2* pInfo,
@@ -1670,6 +1739,20 @@
     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 = HostConnection::get()->vkEncoder();
+    resources->on_vkGetBufferMemoryRequirements2(vkEnc, device, pInfo, pMemoryRequirements);
+}
 static void entry_vkGetImageSparseMemoryRequirements2(
     VkDevice device,
     const VkImageSparseMemoryRequirementsInfo2* pInfo,
@@ -1680,6 +1763,21 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
 static void entry_vkGetPhysicalDeviceFeatures2(
     VkPhysicalDevice physicalDevice,
     VkPhysicalDeviceFeatures2* pFeatures)
@@ -1753,6 +1851,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkTrimCommandPool(device, commandPool, flags);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkTrimCommandPool(device, commandPool, flags);
+}
 static void entry_vkGetDeviceQueue2(
     VkDevice device,
     const VkDeviceQueueInfo2* pQueueInfo,
@@ -1762,6 +1874,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDeviceQueue2(device, pQueueInfo, pQueue);
+}
 static VkResult entry_vkCreateSamplerYcbcrConversion(
     VkDevice device,
     const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
@@ -1775,6 +1901,23 @@
     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 = HostConnection::get()->vkEncoder();
+    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,
@@ -1785,6 +1928,20 @@
     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 = HostConnection::get()->vkEncoder();
+    resources->on_vkDestroySamplerYcbcrConversion(vkEnc, device, ycbcrConversion, pAllocator);
+}
 static VkResult entry_vkCreateDescriptorUpdateTemplate(
     VkDevice device,
     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
@@ -1797,6 +1954,23 @@
     vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDescriptorUpdateTemplate_VkResult_return = (VkResult)0;
+    vkCreateDescriptorUpdateTemplate_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    return vkCreateDescriptorUpdateTemplate_VkResult_return;
+}
 static void entry_vkDestroyDescriptorUpdateTemplate(
     VkDevice device,
     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
@@ -1806,6 +1980,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
+}
 static void entry_vkUpdateDescriptorSetWithTemplate(
     VkDevice device,
     VkDescriptorSet descriptorSet,
@@ -1817,6 +2005,21 @@
     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 = HostConnection::get()->vkEncoder();
+    resources->on_vkUpdateDescriptorSetWithTemplate(vkEnc, device, descriptorSet, descriptorUpdateTemplate, pData);
+}
 static void entry_vkGetPhysicalDeviceExternalBufferProperties(
     VkPhysicalDevice physicalDevice,
     const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
@@ -1854,6 +2057,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+}
 #endif
 #ifdef VK_KHR_surface
 static void entry_vkDestroySurfaceKHR(
@@ -1926,6 +2143,23 @@
     vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
+    vkCreateSwapchainKHR_VkResult_return = vkEnc->vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+    return vkCreateSwapchainKHR_VkResult_return;
+}
 static void entry_vkDestroySwapchainKHR(
     VkDevice device,
     VkSwapchainKHR swapchain,
@@ -1935,6 +2169,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroySwapchainKHR(device, swapchain, pAllocator);
+}
 static VkResult entry_vkGetSwapchainImagesKHR(
     VkDevice device,
     VkSwapchainKHR swapchain,
@@ -1947,6 +2195,23 @@
     vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkGetSwapchainImagesKHR_VkResult_return = (VkResult)0;
+    vkGetSwapchainImagesKHR_VkResult_return = vkEnc->vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
+    return vkGetSwapchainImagesKHR_VkResult_return;
+}
 static VkResult entry_vkAcquireNextImageKHR(
     VkDevice device,
     VkSwapchainKHR swapchain,
@@ -1961,6 +2226,25 @@
     vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkAcquireNextImageKHR_VkResult_return = (VkResult)0;
+    vkAcquireNextImageKHR_VkResult_return = vkEnc->vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
+    return vkAcquireNextImageKHR_VkResult_return;
+}
 static VkResult entry_vkQueuePresentKHR(
     VkQueue queue,
     const VkPresentInfoKHR* pPresentInfo)
@@ -1981,6 +2265,21 @@
     vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = (VkResult)0;
+    vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return = vkEnc->vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities);
+    return vkGetDeviceGroupPresentCapabilitiesKHR_VkResult_return;
+}
 static VkResult entry_vkGetDeviceGroupSurfacePresentModesKHR(
     VkDevice device,
     VkSurfaceKHR surface,
@@ -1992,6 +2291,22 @@
     vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = (VkResult)0;
+    vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
+    return vkGetDeviceGroupSurfacePresentModesKHR_VkResult_return;
+}
 static VkResult entry_vkGetPhysicalDevicePresentRectanglesKHR(
     VkPhysicalDevice physicalDevice,
     VkSurfaceKHR surface,
@@ -2015,6 +2330,22 @@
     vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkAcquireNextImage2KHR_VkResult_return = (VkResult)0;
+    vkAcquireNextImage2KHR_VkResult_return = vkEnc->vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
+    return vkAcquireNextImage2KHR_VkResult_return;
+}
 #endif
 #ifdef VK_KHR_display
 static VkResult entry_vkGetPhysicalDeviceDisplayPropertiesKHR(
@@ -2115,6 +2446,24 @@
     vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
     return vkCreateSharedSwapchainsKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkCreateSharedSwapchainsKHR(
+    VkDevice device,
+    uint32_t swapchainCount,
+    const VkSwapchainCreateInfoKHR* pCreateInfos,
+    const VkAllocationCallbacks* pAllocator,
+    VkSwapchainKHR* pSwapchains)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_display_swapchain"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkCreateSharedSwapchainsKHR", "VK_KHR_display_swapchain");
+    }
+    AEMU_SCOPED_TRACE("vkCreateSharedSwapchainsKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateSharedSwapchainsKHR_VkResult_return = (VkResult)0;
+    vkCreateSharedSwapchainsKHR_VkResult_return = vkEnc->vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
+    return vkCreateSharedSwapchainsKHR_VkResult_return;
+}
 #endif
 #ifdef VK_KHR_xlib_surface
 static VkResult entry_vkCreateXlibSurfaceKHR(
@@ -2338,6 +2687,22 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
 }
+static void dynCheck_entry_vkGetDeviceGroupPeerMemoryFeaturesKHR(
+    VkDevice device,
+    uint32_t heapIndex,
+    uint32_t localDeviceIndex,
+    uint32_t remoteDeviceIndex,
+    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_device_group"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetDeviceGroupPeerMemoryFeaturesKHR", "VK_KHR_device_group");
+    }
+    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeaturesKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
+}
 static void entry_vkCmdSetDeviceMaskKHR(
     VkCommandBuffer commandBuffer,
     uint32_t deviceMask)
@@ -2374,6 +2739,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkTrimCommandPoolKHR(device, commandPool, flags);
+}
 #endif
 #ifdef VK_KHR_device_group_creation
 static VkResult entry_vkEnumeratePhysicalDeviceGroupsKHR(
@@ -2413,6 +2792,22 @@
     vkGetMemoryWin32HandleKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
     return vkGetMemoryWin32HandleKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetMemoryWin32HandleKHR(
+    VkDevice device,
+    const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetMemoryWin32HandleKHR", "VK_KHR_external_memory_win32");
+    }
+    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkGetMemoryWin32HandleKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+    return vkGetMemoryWin32HandleKHR_VkResult_return;
+}
 static VkResult entry_vkGetMemoryWin32HandlePropertiesKHR(
     VkDevice device,
     VkExternalMemoryHandleTypeFlagBits handleType,
@@ -2425,6 +2820,23 @@
     vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
     return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetMemoryWin32HandlePropertiesKHR(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    HANDLE handle,
+    VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_win32"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetMemoryWin32HandlePropertiesKHR", "VK_KHR_external_memory_win32");
+    }
+    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandlePropertiesKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = (VkResult)0;
+    vkGetMemoryWin32HandlePropertiesKHR_VkResult_return = vkEnc->vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties);
+    return vkGetMemoryWin32HandlePropertiesKHR_VkResult_return;
+}
 #endif
 #ifdef VK_KHR_external_memory_fd
 static VkResult entry_vkGetMemoryFdKHR(
@@ -2438,6 +2850,22 @@
     vkGetMemoryFdKHR_VkResult_return = vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd);
     return vkGetMemoryFdKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetMemoryFdKHR(
+    VkDevice device,
+    const VkMemoryGetFdInfoKHR* pGetFdInfo,
+    int* pFd)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetMemoryFdKHR", "VK_KHR_external_memory_fd");
+    }
+    AEMU_SCOPED_TRACE("vkGetMemoryFdKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryFdKHR_VkResult_return = (VkResult)0;
+    vkGetMemoryFdKHR_VkResult_return = vkEnc->vkGetMemoryFdKHR(device, pGetFdInfo, pFd);
+    return vkGetMemoryFdKHR_VkResult_return;
+}
 static VkResult entry_vkGetMemoryFdPropertiesKHR(
     VkDevice device,
     VkExternalMemoryHandleTypeFlagBits handleType,
@@ -2450,6 +2878,23 @@
     vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
     return vkGetMemoryFdPropertiesKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetMemoryFdPropertiesKHR(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    int fd,
+    VkMemoryFdPropertiesKHR* pMemoryFdProperties)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_external_memory_fd"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetMemoryFdPropertiesKHR", "VK_KHR_external_memory_fd");
+    }
+    AEMU_SCOPED_TRACE("vkGetMemoryFdPropertiesKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryFdPropertiesKHR_VkResult_return = (VkResult)0;
+    vkGetMemoryFdPropertiesKHR_VkResult_return = vkEnc->vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties);
+    return vkGetMemoryFdPropertiesKHR_VkResult_return;
+}
 #endif
 #ifdef VK_KHR_win32_keyed_mutex
 #endif
@@ -2477,6 +2922,21 @@
     vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
     return vkImportSemaphoreWin32HandleKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkImportSemaphoreWin32HandleKHR(
+    VkDevice device,
+    const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkImportSemaphoreWin32HandleKHR", "VK_KHR_external_semaphore_win32");
+    }
+    AEMU_SCOPED_TRACE("vkImportSemaphoreWin32HandleKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkImportSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkImportSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
+    return vkImportSemaphoreWin32HandleKHR_VkResult_return;
+}
 static VkResult entry_vkGetSemaphoreWin32HandleKHR(
     VkDevice device,
     const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
@@ -2488,6 +2948,22 @@
     vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
     return vkGetSemaphoreWin32HandleKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetSemaphoreWin32HandleKHR(
+    VkDevice device,
+    const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_external_semaphore_win32"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetSemaphoreWin32HandleKHR", "VK_KHR_external_semaphore_win32");
+    }
+    AEMU_SCOPED_TRACE("vkGetSemaphoreWin32HandleKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSemaphoreWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkGetSemaphoreWin32HandleKHR_VkResult_return = vkEnc->vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+    return vkGetSemaphoreWin32HandleKHR_VkResult_return;
+}
 #endif
 #ifdef VK_KHR_external_semaphore_fd
 static VkResult entry_vkImportSemaphoreFdKHR(
@@ -2501,6 +2977,21 @@
     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 = HostConnection::get()->vkEncoder();
+    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,
@@ -2513,6 +3004,22 @@
     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 = HostConnection::get()->vkEncoder();
+    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_push_descriptor
 static void entry_vkCmdPushDescriptorSetKHR(
@@ -2558,6 +3065,23 @@
     vkCreateDescriptorUpdateTemplateKHR_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkCreateDescriptorUpdateTemplateKHR_VkResult_return = (VkResult)0;
+    vkCreateDescriptorUpdateTemplateKHR_VkResult_return = vkEnc->vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    return vkCreateDescriptorUpdateTemplateKHR_VkResult_return;
+}
 static void entry_vkDestroyDescriptorUpdateTemplateKHR(
     VkDevice device,
     VkDescriptorUpdateTemplate descriptorUpdateTemplate,
@@ -2567,6 +3091,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
+}
 static void entry_vkUpdateDescriptorSetWithTemplateKHR(
     VkDevice device,
     VkDescriptorSet descriptorSet,
@@ -2577,6 +3115,21 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData);
+}
 #endif
 #ifdef VK_KHR_create_renderpass2
 static VkResult entry_vkCreateRenderPass2KHR(
@@ -2591,6 +3144,23 @@
     vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
     return vkCreateRenderPass2KHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkCreateRenderPass2KHR(
+    VkDevice device,
+    const VkRenderPassCreateInfo2KHR* 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 = HostConnection::get()->vkEncoder();
+    VkResult vkCreateRenderPass2KHR_VkResult_return = (VkResult)0;
+    vkCreateRenderPass2KHR_VkResult_return = vkEnc->vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
+    return vkCreateRenderPass2KHR_VkResult_return;
+}
 static void entry_vkCmdBeginRenderPass2KHR(
     VkCommandBuffer commandBuffer,
     const VkRenderPassBeginInfo* pRenderPassBegin,
@@ -2632,6 +3202,21 @@
     vkGetSwapchainStatusKHR_VkResult_return = vkEnc->vkGetSwapchainStatusKHR(device, swapchain);
     return vkGetSwapchainStatusKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetSwapchainStatusKHR(
+    VkDevice device,
+    VkSwapchainKHR swapchain)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_shared_presentable_image"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetSwapchainStatusKHR", "VK_KHR_shared_presentable_image");
+    }
+    AEMU_SCOPED_TRACE("vkGetSwapchainStatusKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSwapchainStatusKHR_VkResult_return = (VkResult)0;
+    vkGetSwapchainStatusKHR_VkResult_return = vkEnc->vkGetSwapchainStatusKHR(device, swapchain);
+    return vkGetSwapchainStatusKHR_VkResult_return;
+}
 #endif
 #ifdef VK_KHR_external_fence_capabilities
 static void entry_vkGetPhysicalDeviceExternalFencePropertiesKHR(
@@ -2658,6 +3243,21 @@
     vkImportFenceWin32HandleKHR_VkResult_return = vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
     return vkImportFenceWin32HandleKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkImportFenceWin32HandleKHR(
+    VkDevice device,
+    const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkImportFenceWin32HandleKHR", "VK_KHR_external_fence_win32");
+    }
+    AEMU_SCOPED_TRACE("vkImportFenceWin32HandleKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkImportFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkImportFenceWin32HandleKHR_VkResult_return = vkEnc->vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
+    return vkImportFenceWin32HandleKHR_VkResult_return;
+}
 static VkResult entry_vkGetFenceWin32HandleKHR(
     VkDevice device,
     const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
@@ -2669,6 +3269,22 @@
     vkGetFenceWin32HandleKHR_VkResult_return = vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
     return vkGetFenceWin32HandleKHR_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetFenceWin32HandleKHR(
+    VkDevice device,
+    const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
+    HANDLE* pHandle)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_KHR_external_fence_win32"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetFenceWin32HandleKHR", "VK_KHR_external_fence_win32");
+    }
+    AEMU_SCOPED_TRACE("vkGetFenceWin32HandleKHR");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetFenceWin32HandleKHR_VkResult_return = (VkResult)0;
+    vkGetFenceWin32HandleKHR_VkResult_return = vkEnc->vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
+    return vkGetFenceWin32HandleKHR_VkResult_return;
+}
 #endif
 #ifdef VK_KHR_external_fence_fd
 static VkResult entry_vkImportFenceFdKHR(
@@ -2682,6 +3298,21 @@
     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 = HostConnection::get()->vkEncoder();
+    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,
@@ -2694,6 +3325,22 @@
     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 = HostConnection::get()->vkEncoder();
+    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
@@ -2788,6 +3435,20 @@
     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 = HostConnection::get()->vkEncoder();
+    resources->on_vkGetImageMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
+}
 static void entry_vkGetBufferMemoryRequirements2KHR(
     VkDevice device,
     const VkBufferMemoryRequirementsInfo2* pInfo,
@@ -2798,6 +3459,20 @@
     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 = HostConnection::get()->vkEncoder();
+    resources->on_vkGetBufferMemoryRequirements2KHR(vkEnc, device, pInfo, pMemoryRequirements);
+}
 static void entry_vkGetImageSparseMemoryRequirements2KHR(
     VkDevice device,
     const VkImageSparseMemoryRequirementsInfo2* pInfo,
@@ -2808,6 +3483,21 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+}
 #endif
 #ifdef VK_KHR_image_format_list
 #endif
@@ -2825,6 +3515,23 @@
     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 = HostConnection::get()->vkEncoder();
+    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,
@@ -2835,6 +3542,20 @@
     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 = HostConnection::get()->vkEncoder();
+    resources->on_vkDestroySamplerYcbcrConversionKHR(vkEnc, device, ycbcrConversion, pAllocator);
+}
 #endif
 #ifdef VK_KHR_bind_memory2
 static VkResult entry_vkBindBufferMemory2KHR(
@@ -2849,6 +3570,22 @@
     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 = HostConnection::get()->vkEncoder();
+    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,
@@ -2861,6 +3598,22 @@
     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 = HostConnection::get()->vkEncoder();
+    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(
@@ -2872,6 +3625,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
 }
+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 = HostConnection::get()->vkEncoder();
+    vkEnc->vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
+}
 #endif
 #ifdef VK_KHR_draw_indirect_count
 static void entry_vkCmdDrawIndirectCountKHR(
@@ -2918,6 +3685,23 @@
     vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkGetSwapchainGrallocUsageANDROID_VkResult_return = (VkResult)0;
+    vkGetSwapchainGrallocUsageANDROID_VkResult_return = vkEnc->vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage);
+    return vkGetSwapchainGrallocUsageANDROID_VkResult_return;
+}
 static VkResult entry_vkAcquireImageANDROID(
     VkDevice device,
     VkImage image,
@@ -2931,6 +3715,24 @@
     vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence);
     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 = HostConnection::get()->vkEncoder();
+    VkResult vkAcquireImageANDROID_VkResult_return = (VkResult)0;
+    vkAcquireImageANDROID_VkResult_return = vkEnc->vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence);
+    return vkAcquireImageANDROID_VkResult_return;
+}
 static VkResult entry_vkQueueSignalReleaseImageANDROID(
     VkQueue queue,
     uint32_t waitSemaphoreCount,
@@ -3005,6 +3807,21 @@
     vkDebugMarkerSetObjectTagEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
     return vkDebugMarkerSetObjectTagEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkDebugMarkerSetObjectTagEXT(
+    VkDevice device,
+    const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkDebugMarkerSetObjectTagEXT", "VK_EXT_debug_marker");
+    }
+    AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectTagEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkDebugMarkerSetObjectTagEXT_VkResult_return = (VkResult)0;
+    vkDebugMarkerSetObjectTagEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectTagEXT(device, pTagInfo);
+    return vkDebugMarkerSetObjectTagEXT_VkResult_return;
+}
 static VkResult entry_vkDebugMarkerSetObjectNameEXT(
     VkDevice device,
     const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
@@ -3015,6 +3832,21 @@
     vkDebugMarkerSetObjectNameEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
     return vkDebugMarkerSetObjectNameEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkDebugMarkerSetObjectNameEXT(
+    VkDevice device,
+    const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_debug_marker"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkDebugMarkerSetObjectNameEXT", "VK_EXT_debug_marker");
+    }
+    AEMU_SCOPED_TRACE("vkDebugMarkerSetObjectNameEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkDebugMarkerSetObjectNameEXT_VkResult_return = (VkResult)0;
+    vkDebugMarkerSetObjectNameEXT_VkResult_return = vkEnc->vkDebugMarkerSetObjectNameEXT(device, pNameInfo);
+    return vkDebugMarkerSetObjectNameEXT_VkResult_return;
+}
 static void entry_vkCmdDebugMarkerBeginEXT(
     VkCommandBuffer commandBuffer,
     const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
@@ -3099,6 +3931,25 @@
     vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
     return vkGetShaderInfoAMD_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetShaderInfoAMD(
+    VkDevice device,
+    VkPipeline pipeline,
+    VkShaderStageFlagBits shaderStage,
+    VkShaderInfoTypeAMD infoType,
+    size_t* pInfoSize,
+    void* pInfo)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_AMD_shader_info"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetShaderInfoAMD", "VK_AMD_shader_info");
+    }
+    AEMU_SCOPED_TRACE("vkGetShaderInfoAMD");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetShaderInfoAMD_VkResult_return = (VkResult)0;
+    vkGetShaderInfoAMD_VkResult_return = vkEnc->vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
+    return vkGetShaderInfoAMD_VkResult_return;
+}
 #endif
 #ifdef VK_AMD_shader_image_load_store_lod
 #endif
@@ -3137,6 +3988,23 @@
     vkGetMemoryWin32HandleNV_VkResult_return = vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle);
     return vkGetMemoryWin32HandleNV_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetMemoryWin32HandleNV(
+    VkDevice device,
+    VkDeviceMemory memory,
+    VkExternalMemoryHandleTypeFlagsNV handleType,
+    HANDLE* pHandle)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_NV_external_memory_win32"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetMemoryWin32HandleNV", "VK_NV_external_memory_win32");
+    }
+    AEMU_SCOPED_TRACE("vkGetMemoryWin32HandleNV");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryWin32HandleNV_VkResult_return = (VkResult)0;
+    vkGetMemoryWin32HandleNV_VkResult_return = vkEnc->vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle);
+    return vkGetMemoryWin32HandleNV_VkResult_return;
+}
 #endif
 #ifdef VK_NV_win32_keyed_mutex
 #endif
@@ -3210,6 +4078,23 @@
     vkCreateIndirectCommandsLayoutNVX_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
     return vkCreateIndirectCommandsLayoutNVX_VkResult_return;
 }
+static VkResult dynCheck_entry_vkCreateIndirectCommandsLayoutNVX(
+    VkDevice device,
+    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkCreateIndirectCommandsLayoutNVX", "VK_NVX_device_generated_commands");
+    }
+    AEMU_SCOPED_TRACE("vkCreateIndirectCommandsLayoutNVX");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateIndirectCommandsLayoutNVX_VkResult_return = (VkResult)0;
+    vkCreateIndirectCommandsLayoutNVX_VkResult_return = vkEnc->vkCreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
+    return vkCreateIndirectCommandsLayoutNVX_VkResult_return;
+}
 static void entry_vkDestroyIndirectCommandsLayoutNVX(
     VkDevice device,
     VkIndirectCommandsLayoutNVX indirectCommandsLayout,
@@ -3219,6 +4104,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
 }
+static void dynCheck_entry_vkDestroyIndirectCommandsLayoutNVX(
+    VkDevice device,
+    VkIndirectCommandsLayoutNVX indirectCommandsLayout,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkDestroyIndirectCommandsLayoutNVX", "VK_NVX_device_generated_commands");
+    }
+    AEMU_SCOPED_TRACE("vkDestroyIndirectCommandsLayoutNVX");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
+}
 static VkResult entry_vkCreateObjectTableNVX(
     VkDevice device,
     const VkObjectTableCreateInfoNVX* pCreateInfo,
@@ -3231,6 +4130,23 @@
     vkCreateObjectTableNVX_VkResult_return = vkEnc->vkCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
     return vkCreateObjectTableNVX_VkResult_return;
 }
+static VkResult dynCheck_entry_vkCreateObjectTableNVX(
+    VkDevice device,
+    const VkObjectTableCreateInfoNVX* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkObjectTableNVX* pObjectTable)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkCreateObjectTableNVX", "VK_NVX_device_generated_commands");
+    }
+    AEMU_SCOPED_TRACE("vkCreateObjectTableNVX");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateObjectTableNVX_VkResult_return = (VkResult)0;
+    vkCreateObjectTableNVX_VkResult_return = vkEnc->vkCreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
+    return vkCreateObjectTableNVX_VkResult_return;
+}
 static void entry_vkDestroyObjectTableNVX(
     VkDevice device,
     VkObjectTableNVX objectTable,
@@ -3240,6 +4156,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkDestroyObjectTableNVX(device, objectTable, pAllocator);
 }
+static void dynCheck_entry_vkDestroyObjectTableNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkDestroyObjectTableNVX", "VK_NVX_device_generated_commands");
+    }
+    AEMU_SCOPED_TRACE("vkDestroyObjectTableNVX");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyObjectTableNVX(device, objectTable, pAllocator);
+}
 static VkResult entry_vkRegisterObjectsNVX(
     VkDevice device,
     VkObjectTableNVX objectTable,
@@ -3253,6 +4183,24 @@
     vkRegisterObjectsNVX_VkResult_return = vkEnc->vkRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
     return vkRegisterObjectsNVX_VkResult_return;
 }
+static VkResult dynCheck_entry_vkRegisterObjectsNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    uint32_t objectCount,
+    const VkObjectTableEntryNVX* const* ppObjectTableEntries,
+    const uint32_t* pObjectIndices)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkRegisterObjectsNVX", "VK_NVX_device_generated_commands");
+    }
+    AEMU_SCOPED_TRACE("vkRegisterObjectsNVX");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkRegisterObjectsNVX_VkResult_return = (VkResult)0;
+    vkRegisterObjectsNVX_VkResult_return = vkEnc->vkRegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
+    return vkRegisterObjectsNVX_VkResult_return;
+}
 static VkResult entry_vkUnregisterObjectsNVX(
     VkDevice device,
     VkObjectTableNVX objectTable,
@@ -3266,6 +4214,24 @@
     vkUnregisterObjectsNVX_VkResult_return = vkEnc->vkUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
     return vkUnregisterObjectsNVX_VkResult_return;
 }
+static VkResult dynCheck_entry_vkUnregisterObjectsNVX(
+    VkDevice device,
+    VkObjectTableNVX objectTable,
+    uint32_t objectCount,
+    const VkObjectEntryTypeNVX* pObjectEntryTypes,
+    const uint32_t* pObjectIndices)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_NVX_device_generated_commands"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkUnregisterObjectsNVX", "VK_NVX_device_generated_commands");
+    }
+    AEMU_SCOPED_TRACE("vkUnregisterObjectsNVX");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkUnregisterObjectsNVX_VkResult_return = (VkResult)0;
+    vkUnregisterObjectsNVX_VkResult_return = vkEnc->vkUnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
+    return vkUnregisterObjectsNVX_VkResult_return;
+}
 static void entry_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
     VkPhysicalDevice physicalDevice,
     VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
@@ -3351,6 +4317,22 @@
     vkDisplayPowerControlEXT_VkResult_return = vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
     return vkDisplayPowerControlEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkDisplayPowerControlEXT(
+    VkDevice device,
+    VkDisplayKHR display,
+    const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_display_control"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkDisplayPowerControlEXT", "VK_EXT_display_control");
+    }
+    AEMU_SCOPED_TRACE("vkDisplayPowerControlEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkDisplayPowerControlEXT_VkResult_return = (VkResult)0;
+    vkDisplayPowerControlEXT_VkResult_return = vkEnc->vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo);
+    return vkDisplayPowerControlEXT_VkResult_return;
+}
 static VkResult entry_vkRegisterDeviceEventEXT(
     VkDevice device,
     const VkDeviceEventInfoEXT* pDeviceEventInfo,
@@ -3363,6 +4345,23 @@
     vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
     return vkRegisterDeviceEventEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkRegisterDeviceEventEXT(
+    VkDevice device,
+    const VkDeviceEventInfoEXT* pDeviceEventInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFence* pFence)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_display_control"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkRegisterDeviceEventEXT", "VK_EXT_display_control");
+    }
+    AEMU_SCOPED_TRACE("vkRegisterDeviceEventEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkRegisterDeviceEventEXT_VkResult_return = (VkResult)0;
+    vkRegisterDeviceEventEXT_VkResult_return = vkEnc->vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
+    return vkRegisterDeviceEventEXT_VkResult_return;
+}
 static VkResult entry_vkRegisterDisplayEventEXT(
     VkDevice device,
     VkDisplayKHR display,
@@ -3376,6 +4375,24 @@
     vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
     return vkRegisterDisplayEventEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkRegisterDisplayEventEXT(
+    VkDevice device,
+    VkDisplayKHR display,
+    const VkDisplayEventInfoEXT* pDisplayEventInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkFence* pFence)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_display_control"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkRegisterDisplayEventEXT", "VK_EXT_display_control");
+    }
+    AEMU_SCOPED_TRACE("vkRegisterDisplayEventEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkRegisterDisplayEventEXT_VkResult_return = (VkResult)0;
+    vkRegisterDisplayEventEXT_VkResult_return = vkEnc->vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
+    return vkRegisterDisplayEventEXT_VkResult_return;
+}
 static VkResult entry_vkGetSwapchainCounterEXT(
     VkDevice device,
     VkSwapchainKHR swapchain,
@@ -3388,6 +4405,23 @@
     vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
     return vkGetSwapchainCounterEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetSwapchainCounterEXT(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    VkSurfaceCounterFlagBitsEXT counter,
+    uint64_t* pCounterValue)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_display_control"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetSwapchainCounterEXT", "VK_EXT_display_control");
+    }
+    AEMU_SCOPED_TRACE("vkGetSwapchainCounterEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetSwapchainCounterEXT_VkResult_return = (VkResult)0;
+    vkGetSwapchainCounterEXT_VkResult_return = vkEnc->vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
+    return vkGetSwapchainCounterEXT_VkResult_return;
+}
 #endif
 #ifdef VK_GOOGLE_display_timing
 static VkResult entry_vkGetRefreshCycleDurationGOOGLE(
@@ -3401,6 +4435,22 @@
     vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
     return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetRefreshCycleDurationGOOGLE(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetRefreshCycleDurationGOOGLE", "VK_GOOGLE_display_timing");
+    }
+    AEMU_SCOPED_TRACE("vkGetRefreshCycleDurationGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetRefreshCycleDurationGOOGLE_VkResult_return = (VkResult)0;
+    vkGetRefreshCycleDurationGOOGLE_VkResult_return = vkEnc->vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
+    return vkGetRefreshCycleDurationGOOGLE_VkResult_return;
+}
 static VkResult entry_vkGetPastPresentationTimingGOOGLE(
     VkDevice device,
     VkSwapchainKHR swapchain,
@@ -3413,6 +4463,23 @@
     vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
     return vkGetPastPresentationTimingGOOGLE_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetPastPresentationTimingGOOGLE(
+    VkDevice device,
+    VkSwapchainKHR swapchain,
+    uint32_t* pPresentationTimingCount,
+    VkPastPresentationTimingGOOGLE* pPresentationTimings)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_display_timing"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetPastPresentationTimingGOOGLE", "VK_GOOGLE_display_timing");
+    }
+    AEMU_SCOPED_TRACE("vkGetPastPresentationTimingGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetPastPresentationTimingGOOGLE_VkResult_return = (VkResult)0;
+    vkGetPastPresentationTimingGOOGLE_VkResult_return = vkEnc->vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
+    return vkGetPastPresentationTimingGOOGLE_VkResult_return;
+}
 #endif
 #ifdef VK_NV_sample_mask_override_coverage
 #endif
@@ -3452,6 +4519,21 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
 }
+static void dynCheck_entry_vkSetHdrMetadataEXT(
+    VkDevice device,
+    uint32_t swapchainCount,
+    const VkSwapchainKHR* pSwapchains,
+    const VkHdrMetadataEXT* pMetadata)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_hdr_metadata"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkSetHdrMetadataEXT", "VK_EXT_hdr_metadata");
+    }
+    AEMU_SCOPED_TRACE("vkSetHdrMetadataEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
+}
 #endif
 #ifdef VK_MVK_ios_surface
 static VkResult entry_vkCreateIOSSurfaceMVK(
@@ -3496,6 +4578,21 @@
     vkSetDebugUtilsObjectNameEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
     return vkSetDebugUtilsObjectNameEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkSetDebugUtilsObjectNameEXT(
+    VkDevice device,
+    const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkSetDebugUtilsObjectNameEXT", "VK_EXT_debug_utils");
+    }
+    AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectNameEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+    vkSetDebugUtilsObjectNameEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectNameEXT(device, pNameInfo);
+    return vkSetDebugUtilsObjectNameEXT_VkResult_return;
+}
 static VkResult entry_vkSetDebugUtilsObjectTagEXT(
     VkDevice device,
     const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
@@ -3506,6 +4603,21 @@
     vkSetDebugUtilsObjectTagEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
     return vkSetDebugUtilsObjectTagEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkSetDebugUtilsObjectTagEXT(
+    VkDevice device,
+    const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_debug_utils"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkSetDebugUtilsObjectTagEXT", "VK_EXT_debug_utils");
+    }
+    AEMU_SCOPED_TRACE("vkSetDebugUtilsObjectTagEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+    vkSetDebugUtilsObjectTagEXT_VkResult_return = vkEnc->vkSetDebugUtilsObjectTagEXT(device, pTagInfo);
+    return vkSetDebugUtilsObjectTagEXT_VkResult_return;
+}
 static void entry_vkQueueBeginDebugUtilsLabelEXT(
     VkQueue queue,
     const VkDebugUtilsLabelEXT* pLabelInfo)
@@ -3600,6 +4712,22 @@
     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 = HostConnection::get()->vkEncoder();
+    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,
@@ -3612,6 +4740,22 @@
     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 = HostConnection::get()->vkEncoder();
+    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_sampler_filter_minmax
 #endif
@@ -3666,6 +4810,23 @@
     vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
     return vkCreateValidationCacheEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkCreateValidationCacheEXT(
+    VkDevice device,
+    const VkValidationCacheCreateInfoEXT* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator,
+    VkValidationCacheEXT* pValidationCache)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkCreateValidationCacheEXT", "VK_EXT_validation_cache");
+    }
+    AEMU_SCOPED_TRACE("vkCreateValidationCacheEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateValidationCacheEXT_VkResult_return = (VkResult)0;
+    vkCreateValidationCacheEXT_VkResult_return = vkEnc->vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
+    return vkCreateValidationCacheEXT_VkResult_return;
+}
 static void entry_vkDestroyValidationCacheEXT(
     VkDevice device,
     VkValidationCacheEXT validationCache,
@@ -3675,6 +4836,20 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
 }
+static void dynCheck_entry_vkDestroyValidationCacheEXT(
+    VkDevice device,
+    VkValidationCacheEXT validationCache,
+    const VkAllocationCallbacks* pAllocator)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkDestroyValidationCacheEXT", "VK_EXT_validation_cache");
+    }
+    AEMU_SCOPED_TRACE("vkDestroyValidationCacheEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkDestroyValidationCacheEXT(device, validationCache, pAllocator);
+}
 static VkResult entry_vkMergeValidationCachesEXT(
     VkDevice device,
     VkValidationCacheEXT dstCache,
@@ -3687,6 +4862,23 @@
     vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
     return vkMergeValidationCachesEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkMergeValidationCachesEXT(
+    VkDevice device,
+    VkValidationCacheEXT dstCache,
+    uint32_t srcCacheCount,
+    const VkValidationCacheEXT* pSrcCaches)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkMergeValidationCachesEXT", "VK_EXT_validation_cache");
+    }
+    AEMU_SCOPED_TRACE("vkMergeValidationCachesEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkMergeValidationCachesEXT_VkResult_return = (VkResult)0;
+    vkMergeValidationCachesEXT_VkResult_return = vkEnc->vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
+    return vkMergeValidationCachesEXT_VkResult_return;
+}
 static VkResult entry_vkGetValidationCacheDataEXT(
     VkDevice device,
     VkValidationCacheEXT validationCache,
@@ -3699,6 +4891,23 @@
     vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
     return vkGetValidationCacheDataEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetValidationCacheDataEXT(
+    VkDevice device,
+    VkValidationCacheEXT validationCache,
+    size_t* pDataSize,
+    void* pData)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_validation_cache"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetValidationCacheDataEXT", "VK_EXT_validation_cache");
+    }
+    AEMU_SCOPED_TRACE("vkGetValidationCacheDataEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetValidationCacheDataEXT_VkResult_return = (VkResult)0;
+    vkGetValidationCacheDataEXT_VkResult_return = vkEnc->vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
+    return vkGetValidationCacheDataEXT_VkResult_return;
+}
 #endif
 #ifdef VK_EXT_descriptor_indexing
 #endif
@@ -3719,6 +4928,23 @@
     vkGetMemoryHostPointerPropertiesEXT_VkResult_return = vkEnc->vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
     return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
 }
+static VkResult dynCheck_entry_vkGetMemoryHostPointerPropertiesEXT(
+    VkDevice device,
+    VkExternalMemoryHandleTypeFlagBits handleType,
+    const void* pHostPointer,
+    VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_EXT_external_memory_host"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkGetMemoryHostPointerPropertiesEXT", "VK_EXT_external_memory_host");
+    }
+    AEMU_SCOPED_TRACE("vkGetMemoryHostPointerPropertiesEXT");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkGetMemoryHostPointerPropertiesEXT_VkResult_return = (VkResult)0;
+    vkGetMemoryHostPointerPropertiesEXT_VkResult_return = vkEnc->vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties);
+    return vkGetMemoryHostPointerPropertiesEXT_VkResult_return;
+}
 #endif
 #ifdef VK_AMD_buffer_marker
 static void entry_vkCmdWriteBufferMarkerAMD(
@@ -3772,6 +4998,22 @@
     vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress);
     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_address_space"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkMapMemoryIntoAddressSpaceGOOGLE", "VK_GOOGLE_address_space");
+    }
+    AEMU_SCOPED_TRACE("vkMapMemoryIntoAddressSpaceGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = (VkResult)0;
+    vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return = vkEnc->vkMapMemoryIntoAddressSpaceGOOGLE(device, memory, pAddress);
+    return vkMapMemoryIntoAddressSpaceGOOGLE_VkResult_return;
+}
 #endif
 #ifdef VK_GOOGLE_color_buffer
 static VkResult entry_vkRegisterImageColorBufferGOOGLE(
@@ -3785,6 +5027,22 @@
     vkRegisterImageColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer);
     return vkRegisterImageColorBufferGOOGLE_VkResult_return;
 }
+static VkResult dynCheck_entry_vkRegisterImageColorBufferGOOGLE(
+    VkDevice device,
+    VkImage image,
+    uint32_t colorBuffer)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_color_buffer"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkRegisterImageColorBufferGOOGLE", "VK_GOOGLE_color_buffer");
+    }
+    AEMU_SCOPED_TRACE("vkRegisterImageColorBufferGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkRegisterImageColorBufferGOOGLE_VkResult_return = (VkResult)0;
+    vkRegisterImageColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterImageColorBufferGOOGLE(device, image, colorBuffer);
+    return vkRegisterImageColorBufferGOOGLE_VkResult_return;
+}
 static VkResult entry_vkRegisterBufferColorBufferGOOGLE(
     VkDevice device,
     VkBuffer buffer,
@@ -3796,6 +5054,22 @@
     vkRegisterBufferColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer);
     return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
 }
+static VkResult dynCheck_entry_vkRegisterBufferColorBufferGOOGLE(
+    VkDevice device,
+    VkBuffer buffer,
+    uint32_t colorBuffer)
+{
+    auto resources = ResourceTracker::get();
+    if (!resources->hasDeviceExtension(device, "VK_GOOGLE_color_buffer"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkRegisterBufferColorBufferGOOGLE", "VK_GOOGLE_color_buffer");
+    }
+    AEMU_SCOPED_TRACE("vkRegisterBufferColorBufferGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkRegisterBufferColorBufferGOOGLE_VkResult_return = (VkResult)0;
+    vkRegisterBufferColorBufferGOOGLE_VkResult_return = vkEnc->vkRegisterBufferColorBufferGOOGLE(device, buffer, colorBuffer);
+    return vkRegisterBufferColorBufferGOOGLE_VkResult_return;
+}
 #endif
 #ifdef VK_GOOGLE_sized_descriptor_update_template
 static void entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
@@ -3816,6 +5090,29 @@
     auto vkEnc = HostConnection::get()->vkEncoder();
     vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews);
 }
+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_sized_descriptor_update_template"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkUpdateDescriptorSetWithTemplateSizedGOOGLE", "VK_GOOGLE_sized_descriptor_update_template");
+    }
+    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplateSizedGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    vkEnc->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews);
+}
 #endif
 #ifdef VK_GOOGLE_async_command_buffers
 static void entry_vkBeginCommandBufferAsyncGOOGLE(
@@ -3869,6 +5166,24 @@
     vkCreateImageWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage, pMemoryRequirements);
     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_create_resources_with_requirements"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkCreateImageWithRequirementsGOOGLE", "VK_GOOGLE_create_resources_with_requirements");
+    }
+    AEMU_SCOPED_TRACE("vkCreateImageWithRequirementsGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateImageWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+    vkCreateImageWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateImageWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pImage, pMemoryRequirements);
+    return vkCreateImageWithRequirementsGOOGLE_VkResult_return;
+}
 static VkResult entry_vkCreateBufferWithRequirementsGOOGLE(
     VkDevice device,
     const VkBufferCreateInfo* pCreateInfo,
@@ -3882,6 +5197,24 @@
     vkCreateBufferWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer, pMemoryRequirements);
     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_create_resources_with_requirements"))
+    {
+        sOnInvalidDynamicallyCheckedCall("vkCreateBufferWithRequirementsGOOGLE", "VK_GOOGLE_create_resources_with_requirements");
+    }
+    AEMU_SCOPED_TRACE("vkCreateBufferWithRequirementsGOOGLE");
+    auto vkEnc = HostConnection::get()->vkEncoder();
+    VkResult vkCreateBufferWithRequirementsGOOGLE_VkResult_return = (VkResult)0;
+    vkCreateBufferWithRequirementsGOOGLE_VkResult_return = vkEnc->vkCreateBufferWithRequirementsGOOGLE(device, pCreateInfo, pAllocator, pBuffer, pMemoryRequirements);
+    return vkCreateBufferWithRequirementsGOOGLE_VkResult_return;
+}
 #endif
 void* goldfish_vulkan_get_proc_address(const char* name){
 #ifdef VK_VERSION_1_0
@@ -5890,15 +7223,15 @@
     }
     if (!strcmp(name, "vkBindBufferMemory2"))
     {
-        return has1_1OrHigher ? (void*)entry_vkBindBufferMemory2 : nullptr;
+        return (void*)dynCheck_entry_vkBindBufferMemory2;
     }
     if (!strcmp(name, "vkBindImageMemory2"))
     {
-        return has1_1OrHigher ? (void*)entry_vkBindImageMemory2 : nullptr;
+        return (void*)dynCheck_entry_vkBindImageMemory2;
     }
     if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeatures"))
     {
-        return has1_1OrHigher ? (void*)entry_vkGetDeviceGroupPeerMemoryFeatures : nullptr;
+        return (void*)dynCheck_entry_vkGetDeviceGroupPeerMemoryFeatures;
     }
     if (!strcmp(name, "vkCmdSetDeviceMask"))
     {
@@ -5914,15 +7247,15 @@
     }
     if (!strcmp(name, "vkGetImageMemoryRequirements2"))
     {
-        return has1_1OrHigher ? (void*)entry_vkGetImageMemoryRequirements2 : nullptr;
+        return (void*)dynCheck_entry_vkGetImageMemoryRequirements2;
     }
     if (!strcmp(name, "vkGetBufferMemoryRequirements2"))
     {
-        return has1_1OrHigher ? (void*)entry_vkGetBufferMemoryRequirements2 : nullptr;
+        return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2;
     }
     if (!strcmp(name, "vkGetImageSparseMemoryRequirements2"))
     {
-        return has1_1OrHigher ? (void*)entry_vkGetImageSparseMemoryRequirements2 : nullptr;
+        return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2;
     }
     if (!strcmp(name, "vkGetPhysicalDeviceFeatures2"))
     {
@@ -5954,31 +7287,31 @@
     }
     if (!strcmp(name, "vkTrimCommandPool"))
     {
-        return has1_1OrHigher ? (void*)entry_vkTrimCommandPool : nullptr;
+        return (void*)dynCheck_entry_vkTrimCommandPool;
     }
     if (!strcmp(name, "vkGetDeviceQueue2"))
     {
-        return has1_1OrHigher ? (void*)entry_vkGetDeviceQueue2 : nullptr;
+        return (void*)dynCheck_entry_vkGetDeviceQueue2;
     }
     if (!strcmp(name, "vkCreateSamplerYcbcrConversion"))
     {
-        return has1_1OrHigher ? (void*)entry_vkCreateSamplerYcbcrConversion : nullptr;
+        return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversion;
     }
     if (!strcmp(name, "vkDestroySamplerYcbcrConversion"))
     {
-        return has1_1OrHigher ? (void*)entry_vkDestroySamplerYcbcrConversion : nullptr;
+        return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversion;
     }
     if (!strcmp(name, "vkCreateDescriptorUpdateTemplate"))
     {
-        return has1_1OrHigher ? (void*)entry_vkCreateDescriptorUpdateTemplate : nullptr;
+        return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplate;
     }
     if (!strcmp(name, "vkDestroyDescriptorUpdateTemplate"))
     {
-        return has1_1OrHigher ? (void*)entry_vkDestroyDescriptorUpdateTemplate : nullptr;
+        return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplate;
     }
     if (!strcmp(name, "vkUpdateDescriptorSetWithTemplate"))
     {
-        return has1_1OrHigher ? (void*)entry_vkUpdateDescriptorSetWithTemplate : nullptr;
+        return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplate;
     }
     if (!strcmp(name, "vkGetPhysicalDeviceExternalBufferProperties"))
     {
@@ -5994,7 +7327,7 @@
     }
     if (!strcmp(name, "vkGetDescriptorSetLayoutSupport"))
     {
-        return has1_1OrHigher ? (void*)entry_vkGetDescriptorSetLayoutSupport : nullptr;
+        return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupport;
     }
 #endif
 #ifdef VK_KHR_surface
@@ -6027,23 +7360,19 @@
 #ifdef VK_KHR_swapchain
     if (!strcmp(name, "vkCreateSwapchainKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
-        return hasExt ? (void*)entry_vkCreateSwapchainKHR : nullptr;
+        return (void*)dynCheck_entry_vkCreateSwapchainKHR;
     }
     if (!strcmp(name, "vkDestroySwapchainKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
-        return hasExt ? (void*)entry_vkDestroySwapchainKHR : nullptr;
+        return (void*)dynCheck_entry_vkDestroySwapchainKHR;
     }
     if (!strcmp(name, "vkGetSwapchainImagesKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
-        return hasExt ? (void*)entry_vkGetSwapchainImagesKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetSwapchainImagesKHR;
     }
     if (!strcmp(name, "vkAcquireNextImageKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
-        return hasExt ? (void*)entry_vkAcquireNextImageKHR : nullptr;
+        return (void*)dynCheck_entry_vkAcquireNextImageKHR;
     }
     if (!strcmp(name, "vkQueuePresentKHR"))
     {
@@ -6052,13 +7381,11 @@
     }
     if (!strcmp(name, "vkGetDeviceGroupPresentCapabilitiesKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
-        return hasExt ? (void*)entry_vkGetDeviceGroupPresentCapabilitiesKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetDeviceGroupPresentCapabilitiesKHR;
     }
     if (!strcmp(name, "vkGetDeviceGroupSurfacePresentModesKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
-        return hasExt ? (void*)entry_vkGetDeviceGroupSurfacePresentModesKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetDeviceGroupSurfacePresentModesKHR;
     }
     if (!strcmp(name, "vkGetPhysicalDevicePresentRectanglesKHR"))
     {
@@ -6067,8 +7394,7 @@
     }
     if (!strcmp(name, "vkAcquireNextImage2KHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_swapchain");
-        return hasExt ? (void*)entry_vkAcquireNextImage2KHR : nullptr;
+        return (void*)dynCheck_entry_vkAcquireNextImage2KHR;
     }
 #endif
 #ifdef VK_KHR_display
@@ -6111,8 +7437,7 @@
 #ifdef VK_KHR_display_swapchain
     if (!strcmp(name, "vkCreateSharedSwapchainsKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_display_swapchain");
-        return hasExt ? (void*)entry_vkCreateSharedSwapchainsKHR : nullptr;
+        return (void*)dynCheck_entry_vkCreateSharedSwapchainsKHR;
     }
 #endif
 #ifdef VK_KHR_xlib_surface
@@ -6222,8 +7547,7 @@
 #ifdef VK_KHR_device_group
     if (!strcmp(name, "vkGetDeviceGroupPeerMemoryFeaturesKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_device_group");
-        return hasExt ? (void*)entry_vkGetDeviceGroupPeerMemoryFeaturesKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetDeviceGroupPeerMemoryFeaturesKHR;
     }
     if (!strcmp(name, "vkCmdSetDeviceMaskKHR"))
     {
@@ -6239,8 +7563,7 @@
 #ifdef VK_KHR_maintenance1
     if (!strcmp(name, "vkTrimCommandPoolKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_maintenance1");
-        return hasExt ? (void*)entry_vkTrimCommandPoolKHR : nullptr;
+        return (void*)dynCheck_entry_vkTrimCommandPoolKHR;
     }
 #endif
 #ifdef VK_KHR_device_group_creation
@@ -6260,25 +7583,21 @@
 #ifdef VK_KHR_external_memory_win32
     if (!strcmp(name, "vkGetMemoryWin32HandleKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_win32");
-        return hasExt ? (void*)entry_vkGetMemoryWin32HandleKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetMemoryWin32HandleKHR;
     }
     if (!strcmp(name, "vkGetMemoryWin32HandlePropertiesKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_win32");
-        return hasExt ? (void*)entry_vkGetMemoryWin32HandlePropertiesKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetMemoryWin32HandlePropertiesKHR;
     }
 #endif
 #ifdef VK_KHR_external_memory_fd
     if (!strcmp(name, "vkGetMemoryFdKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_fd");
-        return hasExt ? (void*)entry_vkGetMemoryFdKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetMemoryFdKHR;
     }
     if (!strcmp(name, "vkGetMemoryFdPropertiesKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_memory_fd");
-        return hasExt ? (void*)entry_vkGetMemoryFdPropertiesKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetMemoryFdPropertiesKHR;
     }
 #endif
 #ifdef VK_KHR_external_semaphore_capabilities
@@ -6291,25 +7610,21 @@
 #ifdef VK_KHR_external_semaphore_win32
     if (!strcmp(name, "vkImportSemaphoreWin32HandleKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_win32");
-        return hasExt ? (void*)entry_vkImportSemaphoreWin32HandleKHR : nullptr;
+        return (void*)dynCheck_entry_vkImportSemaphoreWin32HandleKHR;
     }
     if (!strcmp(name, "vkGetSemaphoreWin32HandleKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_win32");
-        return hasExt ? (void*)entry_vkGetSemaphoreWin32HandleKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetSemaphoreWin32HandleKHR;
     }
 #endif
 #ifdef VK_KHR_external_semaphore_fd
     if (!strcmp(name, "vkImportSemaphoreFdKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_fd");
-        return hasExt ? (void*)entry_vkImportSemaphoreFdKHR : nullptr;
+        return (void*)dynCheck_entry_vkImportSemaphoreFdKHR;
     }
     if (!strcmp(name, "vkGetSemaphoreFdKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_semaphore_fd");
-        return hasExt ? (void*)entry_vkGetSemaphoreFdKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetSemaphoreFdKHR;
     }
 #endif
 #ifdef VK_KHR_push_descriptor
@@ -6327,25 +7642,21 @@
 #ifdef VK_KHR_descriptor_update_template
     if (!strcmp(name, "vkCreateDescriptorUpdateTemplateKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_descriptor_update_template");
-        return hasExt ? (void*)entry_vkCreateDescriptorUpdateTemplateKHR : nullptr;
+        return (void*)dynCheck_entry_vkCreateDescriptorUpdateTemplateKHR;
     }
     if (!strcmp(name, "vkDestroyDescriptorUpdateTemplateKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_descriptor_update_template");
-        return hasExt ? (void*)entry_vkDestroyDescriptorUpdateTemplateKHR : nullptr;
+        return (void*)dynCheck_entry_vkDestroyDescriptorUpdateTemplateKHR;
     }
     if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_descriptor_update_template");
-        return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateKHR : nullptr;
+        return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateKHR;
     }
 #endif
 #ifdef VK_KHR_create_renderpass2
     if (!strcmp(name, "vkCreateRenderPass2KHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_create_renderpass2");
-        return hasExt ? (void*)entry_vkCreateRenderPass2KHR : nullptr;
+        return (void*)dynCheck_entry_vkCreateRenderPass2KHR;
     }
     if (!strcmp(name, "vkCmdBeginRenderPass2KHR"))
     {
@@ -6366,8 +7677,7 @@
 #ifdef VK_KHR_shared_presentable_image
     if (!strcmp(name, "vkGetSwapchainStatusKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_shared_presentable_image");
-        return hasExt ? (void*)entry_vkGetSwapchainStatusKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetSwapchainStatusKHR;
     }
 #endif
 #ifdef VK_KHR_external_fence_capabilities
@@ -6380,25 +7690,21 @@
 #ifdef VK_KHR_external_fence_win32
     if (!strcmp(name, "vkImportFenceWin32HandleKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_win32");
-        return hasExt ? (void*)entry_vkImportFenceWin32HandleKHR : nullptr;
+        return (void*)dynCheck_entry_vkImportFenceWin32HandleKHR;
     }
     if (!strcmp(name, "vkGetFenceWin32HandleKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_win32");
-        return hasExt ? (void*)entry_vkGetFenceWin32HandleKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetFenceWin32HandleKHR;
     }
 #endif
 #ifdef VK_KHR_external_fence_fd
     if (!strcmp(name, "vkImportFenceFdKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_fd");
-        return hasExt ? (void*)entry_vkImportFenceFdKHR : nullptr;
+        return (void*)dynCheck_entry_vkImportFenceFdKHR;
     }
     if (!strcmp(name, "vkGetFenceFdKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_external_fence_fd");
-        return hasExt ? (void*)entry_vkGetFenceFdKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetFenceFdKHR;
     }
 #endif
 #ifdef VK_KHR_get_surface_capabilities2
@@ -6438,49 +7744,41 @@
 #ifdef VK_KHR_get_memory_requirements2
     if (!strcmp(name, "vkGetImageMemoryRequirements2KHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_memory_requirements2");
-        return hasExt ? (void*)entry_vkGetImageMemoryRequirements2KHR : nullptr;
+        return (void*)dynCheck_entry_vkGetImageMemoryRequirements2KHR;
     }
     if (!strcmp(name, "vkGetBufferMemoryRequirements2KHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_memory_requirements2");
-        return hasExt ? (void*)entry_vkGetBufferMemoryRequirements2KHR : nullptr;
+        return (void*)dynCheck_entry_vkGetBufferMemoryRequirements2KHR;
     }
     if (!strcmp(name, "vkGetImageSparseMemoryRequirements2KHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_get_memory_requirements2");
-        return hasExt ? (void*)entry_vkGetImageSparseMemoryRequirements2KHR : nullptr;
+        return (void*)dynCheck_entry_vkGetImageSparseMemoryRequirements2KHR;
     }
 #endif
 #ifdef VK_KHR_sampler_ycbcr_conversion
     if (!strcmp(name, "vkCreateSamplerYcbcrConversionKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_sampler_ycbcr_conversion");
-        return hasExt ? (void*)entry_vkCreateSamplerYcbcrConversionKHR : nullptr;
+        return (void*)dynCheck_entry_vkCreateSamplerYcbcrConversionKHR;
     }
     if (!strcmp(name, "vkDestroySamplerYcbcrConversionKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_sampler_ycbcr_conversion");
-        return hasExt ? (void*)entry_vkDestroySamplerYcbcrConversionKHR : nullptr;
+        return (void*)dynCheck_entry_vkDestroySamplerYcbcrConversionKHR;
     }
 #endif
 #ifdef VK_KHR_bind_memory2
     if (!strcmp(name, "vkBindBufferMemory2KHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_bind_memory2");
-        return hasExt ? (void*)entry_vkBindBufferMemory2KHR : nullptr;
+        return (void*)dynCheck_entry_vkBindBufferMemory2KHR;
     }
     if (!strcmp(name, "vkBindImageMemory2KHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_bind_memory2");
-        return hasExt ? (void*)entry_vkBindImageMemory2KHR : nullptr;
+        return (void*)dynCheck_entry_vkBindImageMemory2KHR;
     }
 #endif
 #ifdef VK_KHR_maintenance3
     if (!strcmp(name, "vkGetDescriptorSetLayoutSupportKHR"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_KHR_maintenance3");
-        return hasExt ? (void*)entry_vkGetDescriptorSetLayoutSupportKHR : nullptr;
+        return (void*)dynCheck_entry_vkGetDescriptorSetLayoutSupportKHR;
     }
 #endif
 #ifdef VK_KHR_draw_indirect_count
@@ -6498,13 +7796,11 @@
 #ifdef VK_ANDROID_native_buffer
     if (!strcmp(name, "vkGetSwapchainGrallocUsageANDROID"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_native_buffer");
-        return hasExt ? (void*)entry_vkGetSwapchainGrallocUsageANDROID : nullptr;
+        return (void*)dynCheck_entry_vkGetSwapchainGrallocUsageANDROID;
     }
     if (!strcmp(name, "vkAcquireImageANDROID"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_native_buffer");
-        return hasExt ? (void*)entry_vkAcquireImageANDROID : nullptr;
+        return (void*)dynCheck_entry_vkAcquireImageANDROID;
     }
     if (!strcmp(name, "vkQueueSignalReleaseImageANDROID"))
     {
@@ -6532,13 +7828,11 @@
 #ifdef VK_EXT_debug_marker
     if (!strcmp(name, "vkDebugMarkerSetObjectTagEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_marker");
-        return hasExt ? (void*)entry_vkDebugMarkerSetObjectTagEXT : nullptr;
+        return (void*)dynCheck_entry_vkDebugMarkerSetObjectTagEXT;
     }
     if (!strcmp(name, "vkDebugMarkerSetObjectNameEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_marker");
-        return hasExt ? (void*)entry_vkDebugMarkerSetObjectNameEXT : nullptr;
+        return (void*)dynCheck_entry_vkDebugMarkerSetObjectNameEXT;
     }
     if (!strcmp(name, "vkCmdDebugMarkerBeginEXT"))
     {
@@ -6571,8 +7865,7 @@
 #ifdef VK_AMD_shader_info
     if (!strcmp(name, "vkGetShaderInfoAMD"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_AMD_shader_info");
-        return hasExt ? (void*)entry_vkGetShaderInfoAMD : nullptr;
+        return (void*)dynCheck_entry_vkGetShaderInfoAMD;
     }
 #endif
 #ifdef VK_NV_external_memory_capabilities
@@ -6585,8 +7878,7 @@
 #ifdef VK_NV_external_memory_win32
     if (!strcmp(name, "vkGetMemoryWin32HandleNV"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_NV_external_memory_win32");
-        return hasExt ? (void*)entry_vkGetMemoryWin32HandleNV : nullptr;
+        return (void*)dynCheck_entry_vkGetMemoryWin32HandleNV;
     }
 #endif
 #ifdef VK_NN_vi_surface
@@ -6621,33 +7913,27 @@
     }
     if (!strcmp(name, "vkCreateIndirectCommandsLayoutNVX"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands");
-        return hasExt ? (void*)entry_vkCreateIndirectCommandsLayoutNVX : nullptr;
+        return (void*)dynCheck_entry_vkCreateIndirectCommandsLayoutNVX;
     }
     if (!strcmp(name, "vkDestroyIndirectCommandsLayoutNVX"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands");
-        return hasExt ? (void*)entry_vkDestroyIndirectCommandsLayoutNVX : nullptr;
+        return (void*)dynCheck_entry_vkDestroyIndirectCommandsLayoutNVX;
     }
     if (!strcmp(name, "vkCreateObjectTableNVX"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands");
-        return hasExt ? (void*)entry_vkCreateObjectTableNVX : nullptr;
+        return (void*)dynCheck_entry_vkCreateObjectTableNVX;
     }
     if (!strcmp(name, "vkDestroyObjectTableNVX"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands");
-        return hasExt ? (void*)entry_vkDestroyObjectTableNVX : nullptr;
+        return (void*)dynCheck_entry_vkDestroyObjectTableNVX;
     }
     if (!strcmp(name, "vkRegisterObjectsNVX"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands");
-        return hasExt ? (void*)entry_vkRegisterObjectsNVX : nullptr;
+        return (void*)dynCheck_entry_vkRegisterObjectsNVX;
     }
     if (!strcmp(name, "vkUnregisterObjectsNVX"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_NVX_device_generated_commands");
-        return hasExt ? (void*)entry_vkUnregisterObjectsNVX : nullptr;
+        return (void*)dynCheck_entry_vkUnregisterObjectsNVX;
     }
     if (!strcmp(name, "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"))
     {
@@ -6691,35 +7977,29 @@
 #ifdef VK_EXT_display_control
     if (!strcmp(name, "vkDisplayPowerControlEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_control");
-        return hasExt ? (void*)entry_vkDisplayPowerControlEXT : nullptr;
+        return (void*)dynCheck_entry_vkDisplayPowerControlEXT;
     }
     if (!strcmp(name, "vkRegisterDeviceEventEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_control");
-        return hasExt ? (void*)entry_vkRegisterDeviceEventEXT : nullptr;
+        return (void*)dynCheck_entry_vkRegisterDeviceEventEXT;
     }
     if (!strcmp(name, "vkRegisterDisplayEventEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_control");
-        return hasExt ? (void*)entry_vkRegisterDisplayEventEXT : nullptr;
+        return (void*)dynCheck_entry_vkRegisterDisplayEventEXT;
     }
     if (!strcmp(name, "vkGetSwapchainCounterEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_display_control");
-        return hasExt ? (void*)entry_vkGetSwapchainCounterEXT : nullptr;
+        return (void*)dynCheck_entry_vkGetSwapchainCounterEXT;
     }
 #endif
 #ifdef VK_GOOGLE_display_timing
     if (!strcmp(name, "vkGetRefreshCycleDurationGOOGLE"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_display_timing");
-        return hasExt ? (void*)entry_vkGetRefreshCycleDurationGOOGLE : nullptr;
+        return (void*)dynCheck_entry_vkGetRefreshCycleDurationGOOGLE;
     }
     if (!strcmp(name, "vkGetPastPresentationTimingGOOGLE"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_display_timing");
-        return hasExt ? (void*)entry_vkGetPastPresentationTimingGOOGLE : nullptr;
+        return (void*)dynCheck_entry_vkGetPastPresentationTimingGOOGLE;
     }
 #endif
 #ifdef VK_EXT_discard_rectangles
@@ -6732,8 +8012,7 @@
 #ifdef VK_EXT_hdr_metadata
     if (!strcmp(name, "vkSetHdrMetadataEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_hdr_metadata");
-        return hasExt ? (void*)entry_vkSetHdrMetadataEXT : nullptr;
+        return (void*)dynCheck_entry_vkSetHdrMetadataEXT;
     }
 #endif
 #ifdef VK_MVK_ios_surface
@@ -6753,13 +8032,11 @@
 #ifdef VK_EXT_debug_utils
     if (!strcmp(name, "vkSetDebugUtilsObjectNameEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
-        return hasExt ? (void*)entry_vkSetDebugUtilsObjectNameEXT : nullptr;
+        return (void*)dynCheck_entry_vkSetDebugUtilsObjectNameEXT;
     }
     if (!strcmp(name, "vkSetDebugUtilsObjectTagEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_debug_utils");
-        return hasExt ? (void*)entry_vkSetDebugUtilsObjectTagEXT : nullptr;
+        return (void*)dynCheck_entry_vkSetDebugUtilsObjectTagEXT;
     }
     if (!strcmp(name, "vkQueueBeginDebugUtilsLabelEXT"))
     {
@@ -6810,13 +8087,11 @@
 #ifdef VK_ANDROID_external_memory_android_hardware_buffer
     if (!strcmp(name, "vkGetAndroidHardwareBufferPropertiesANDROID"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_external_memory_android_hardware_buffer");
-        return hasExt ? (void*)entry_vkGetAndroidHardwareBufferPropertiesANDROID : nullptr;
+        return (void*)dynCheck_entry_vkGetAndroidHardwareBufferPropertiesANDROID;
     }
     if (!strcmp(name, "vkGetMemoryAndroidHardwareBufferANDROID"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_ANDROID_external_memory_android_hardware_buffer");
-        return hasExt ? (void*)entry_vkGetMemoryAndroidHardwareBufferANDROID : nullptr;
+        return (void*)dynCheck_entry_vkGetMemoryAndroidHardwareBufferANDROID;
     }
 #endif
 #ifdef VK_EXT_sample_locations
@@ -6834,30 +8109,25 @@
 #ifdef VK_EXT_validation_cache
     if (!strcmp(name, "vkCreateValidationCacheEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_validation_cache");
-        return hasExt ? (void*)entry_vkCreateValidationCacheEXT : nullptr;
+        return (void*)dynCheck_entry_vkCreateValidationCacheEXT;
     }
     if (!strcmp(name, "vkDestroyValidationCacheEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_validation_cache");
-        return hasExt ? (void*)entry_vkDestroyValidationCacheEXT : nullptr;
+        return (void*)dynCheck_entry_vkDestroyValidationCacheEXT;
     }
     if (!strcmp(name, "vkMergeValidationCachesEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_validation_cache");
-        return hasExt ? (void*)entry_vkMergeValidationCachesEXT : nullptr;
+        return (void*)dynCheck_entry_vkMergeValidationCachesEXT;
     }
     if (!strcmp(name, "vkGetValidationCacheDataEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_validation_cache");
-        return hasExt ? (void*)entry_vkGetValidationCacheDataEXT : nullptr;
+        return (void*)dynCheck_entry_vkGetValidationCacheDataEXT;
     }
 #endif
 #ifdef VK_EXT_external_memory_host
     if (!strcmp(name, "vkGetMemoryHostPointerPropertiesEXT"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_EXT_external_memory_host");
-        return hasExt ? (void*)entry_vkGetMemoryHostPointerPropertiesEXT : nullptr;
+        return (void*)dynCheck_entry_vkGetMemoryHostPointerPropertiesEXT;
     }
 #endif
 #ifdef VK_AMD_buffer_marker
@@ -6882,27 +8152,23 @@
 #ifdef VK_GOOGLE_address_space
     if (!strcmp(name, "vkMapMemoryIntoAddressSpaceGOOGLE"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_address_space");
-        return hasExt ? (void*)entry_vkMapMemoryIntoAddressSpaceGOOGLE : nullptr;
+        return (void*)dynCheck_entry_vkMapMemoryIntoAddressSpaceGOOGLE;
     }
 #endif
 #ifdef VK_GOOGLE_color_buffer
     if (!strcmp(name, "vkRegisterImageColorBufferGOOGLE"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_color_buffer");
-        return hasExt ? (void*)entry_vkRegisterImageColorBufferGOOGLE : nullptr;
+        return (void*)dynCheck_entry_vkRegisterImageColorBufferGOOGLE;
     }
     if (!strcmp(name, "vkRegisterBufferColorBufferGOOGLE"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_color_buffer");
-        return hasExt ? (void*)entry_vkRegisterBufferColorBufferGOOGLE : nullptr;
+        return (void*)dynCheck_entry_vkRegisterBufferColorBufferGOOGLE;
     }
 #endif
 #ifdef VK_GOOGLE_sized_descriptor_update_template
     if (!strcmp(name, "vkUpdateDescriptorSetWithTemplateSizedGOOGLE"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_sized_descriptor_update_template");
-        return hasExt ? (void*)entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE : nullptr;
+        return (void*)dynCheck_entry_vkUpdateDescriptorSetWithTemplateSizedGOOGLE;
     }
 #endif
 #ifdef VK_GOOGLE_async_command_buffers
@@ -6930,13 +8196,11 @@
 #ifdef VK_GOOGLE_create_resources_with_requirements
     if (!strcmp(name, "vkCreateImageWithRequirementsGOOGLE"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_create_resources_with_requirements");
-        return hasExt ? (void*)entry_vkCreateImageWithRequirementsGOOGLE : nullptr;
+        return (void*)dynCheck_entry_vkCreateImageWithRequirementsGOOGLE;
     }
     if (!strcmp(name, "vkCreateBufferWithRequirementsGOOGLE"))
     {
-        bool hasExt = resources->hasInstanceExtension(instance, "VK_GOOGLE_create_resources_with_requirements");
-        return hasExt ? (void*)entry_vkCreateBufferWithRequirementsGOOGLE : nullptr;
+        return (void*)dynCheck_entry_vkCreateBufferWithRequirementsGOOGLE;
     }
 #endif
     return nullptr;