system/vulkan/func_table.cpp

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

// Autogenerated module func_table
// (impl) generated by android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/genvk.py -registry android/android-emugl/host/libs/libOpenglRender/vulkan-registry/xml/vk.xml cereal -o android/android-emugl/host/libs/libOpenglRender/vulkan/cereal
// Please do not modify directly;
// re-run android/scripts/generate-vulkan-sources.sh,
// or directly from Python by defining:
// VULKAN_REGISTRY_XML_DIR : Directory containing genvk.py and vk.xml
// CEREAL_OUTPUT_DIR: Where to put the generated sources.
// python3 $VULKAN_REGISTRY_XML_DIR/genvk.py -registry $VULKAN_REGISTRY_XML_DIR/vk.xml cereal -o $CEREAL_OUTPUT_DIR

#include "func_table.h"


#include "VkEncoder.h"
#include "HostConnection.h"
#include "ResourceTracker.h"

#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
// implement them completely on the guest side.
#undef VK_KHR_android_surface


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,
    const VkAllocationCallbacks* pAllocator,
    VkInstance* pInstance)
{
    AEMU_SCOPED_TRACE("vkCreateInstance");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateInstance_VkResult_return = (VkResult)0;
    vkCreateInstance_VkResult_return = vkEnc->vkCreateInstance(pCreateInfo, pAllocator, pInstance);
    return vkCreateInstance_VkResult_return;
}
static void entry_vkDestroyInstance(
    VkInstance instance,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyInstance");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyInstance(instance, pAllocator);
}
static VkResult entry_vkEnumeratePhysicalDevices(
    VkInstance instance,
    uint32_t* pPhysicalDeviceCount,
    VkPhysicalDevice* pPhysicalDevices)
{
    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDevices");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkEnumeratePhysicalDevices_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkEnumeratePhysicalDevices_VkResult_return = resources->on_vkEnumeratePhysicalDevices(vkEnc, VK_SUCCESS, instance, pPhysicalDeviceCount, pPhysicalDevices);
    return vkEnumeratePhysicalDevices_VkResult_return;
}
static void entry_vkGetPhysicalDeviceFeatures(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures* pFeatures)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures);
}
static void entry_vkGetPhysicalDeviceFormatProperties(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties* pFormatProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkImageFormatProperties* pImageFormatProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDeviceImageFormatProperties_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceImageFormatProperties_VkResult_return = vkEnc->vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
    return vkGetPhysicalDeviceImageFormatProperties_VkResult_return;
}
static void entry_vkGetPhysicalDeviceProperties(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties* pProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceProperties(physicalDevice, pProperties);
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties(
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties* pQueueFamilyProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
static void entry_vkGetPhysicalDeviceMemoryProperties(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties);
}
static PFN_vkVoidFunction entry_vkGetInstanceProcAddr(
    VkInstance instance,
    const char* pName)
{
    AEMU_SCOPED_TRACE("vkGetInstanceProcAddr");
    auto vkEnc = HostConnection::get()->vkEncoder();
    PFN_vkVoidFunction vkGetInstanceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
    vkGetInstanceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetInstanceProcAddr(instance, pName);
    return vkGetInstanceProcAddr_PFN_vkVoidFunction_return;
}
static PFN_vkVoidFunction entry_vkGetDeviceProcAddr(
    VkDevice device,
    const char* pName)
{
    AEMU_SCOPED_TRACE("vkGetDeviceProcAddr");
    auto vkEnc = HostConnection::get()->vkEncoder();
    PFN_vkVoidFunction vkGetDeviceProcAddr_PFN_vkVoidFunction_return = (PFN_vkVoidFunction)0;
    vkGetDeviceProcAddr_PFN_vkVoidFunction_return = vkEnc->vkGetDeviceProcAddr(device, pName);
    return vkGetDeviceProcAddr_PFN_vkVoidFunction_return;
}
static VkResult entry_vkCreateDevice(
    VkPhysicalDevice physicalDevice,
    const VkDeviceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDevice* pDevice)
{
    AEMU_SCOPED_TRACE("vkCreateDevice");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateDevice_VkResult_return = (VkResult)0;
    vkCreateDevice_VkResult_return = vkEnc->vkCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
    return vkCreateDevice_VkResult_return;
}
static void entry_vkDestroyDevice(
    VkDevice device,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyDevice");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyDevice(device, pAllocator);
}
static VkResult entry_vkEnumerateInstanceExtensionProperties(
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
    AEMU_SCOPED_TRACE("vkEnumerateInstanceExtensionProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkEnumerateInstanceExtensionProperties_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkEnumerateInstanceExtensionProperties_VkResult_return = resources->on_vkEnumerateInstanceExtensionProperties(vkEnc, VK_SUCCESS, pLayerName, pPropertyCount, pProperties);
    return vkEnumerateInstanceExtensionProperties_VkResult_return;
}
static VkResult entry_vkEnumerateDeviceExtensionProperties(
    VkPhysicalDevice physicalDevice,
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
    AEMU_SCOPED_TRACE("vkEnumerateDeviceExtensionProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkEnumerateDeviceExtensionProperties_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkEnumerateDeviceExtensionProperties_VkResult_return = resources->on_vkEnumerateDeviceExtensionProperties(vkEnc, VK_SUCCESS, physicalDevice, pLayerName, pPropertyCount, pProperties);
    return vkEnumerateDeviceExtensionProperties_VkResult_return;
}
static VkResult entry_vkEnumerateInstanceLayerProperties(
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
    AEMU_SCOPED_TRACE("vkEnumerateInstanceLayerProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkEnumerateInstanceLayerProperties_VkResult_return = (VkResult)0;
    vkEnumerateInstanceLayerProperties_VkResult_return = vkEnc->vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
    return vkEnumerateInstanceLayerProperties_VkResult_return;
}
static VkResult entry_vkEnumerateDeviceLayerProperties(
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
    AEMU_SCOPED_TRACE("vkEnumerateDeviceLayerProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkEnumerateDeviceLayerProperties_VkResult_return = (VkResult)0;
    vkEnumerateDeviceLayerProperties_VkResult_return = vkEnc->vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
    return vkEnumerateDeviceLayerProperties_VkResult_return;
}
static void entry_vkGetDeviceQueue(
    VkDevice device,
    uint32_t queueFamilyIndex,
    uint32_t queueIndex,
    VkQueue* pQueue)
{
    AEMU_SCOPED_TRACE("vkGetDeviceQueue");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
}
static VkResult entry_vkQueueSubmit(
    VkQueue queue,
    uint32_t submitCount,
    const VkSubmitInfo* pSubmits,
    VkFence fence)
{
    AEMU_SCOPED_TRACE("vkQueueSubmit");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkQueueSubmit_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkQueueSubmit_VkResult_return = resources->on_vkQueueSubmit(vkEnc, VK_SUCCESS, queue, submitCount, pSubmits, fence);
    return vkQueueSubmit_VkResult_return;
}
static VkResult entry_vkQueueWaitIdle(
    VkQueue queue)
{
    AEMU_SCOPED_TRACE("vkQueueWaitIdle");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkQueueWaitIdle_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkQueueWaitIdle_VkResult_return = resources->on_vkQueueWaitIdle(vkEnc, VK_SUCCESS, queue);
    return vkQueueWaitIdle_VkResult_return;
}
static VkResult entry_vkDeviceWaitIdle(
    VkDevice device)
{
    AEMU_SCOPED_TRACE("vkDeviceWaitIdle");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkDeviceWaitIdle_VkResult_return = (VkResult)0;
    vkDeviceWaitIdle_VkResult_return = vkEnc->vkDeviceWaitIdle(device);
    return vkDeviceWaitIdle_VkResult_return;
}
static VkResult entry_vkAllocateMemory(
    VkDevice device,
    const VkMemoryAllocateInfo* pAllocateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDeviceMemory* pMemory)
{
    AEMU_SCOPED_TRACE("vkAllocateMemory");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkAllocateMemory_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkAllocateMemory_VkResult_return = resources->on_vkAllocateMemory(vkEnc, VK_SUCCESS, device, pAllocateInfo, pAllocator, pMemory);
    return vkAllocateMemory_VkResult_return;
}
static void entry_vkFreeMemory(
    VkDevice device,
    VkDeviceMemory memory,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkFreeMemory");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkFreeMemory(vkEnc, device, memory, pAllocator);
}
static VkResult entry_vkMapMemory(
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize offset,
    VkDeviceSize size,
    VkMemoryMapFlags flags,
    void** ppData)
{
    AEMU_SCOPED_TRACE("vkMapMemory");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkMapMemory_VkResult_return = (VkResult)0;
    vkMapMemory_VkResult_return = vkEnc->vkMapMemory(device, memory, offset, size, flags, ppData);
    return vkMapMemory_VkResult_return;
}
static void entry_vkUnmapMemory(
    VkDevice device,
    VkDeviceMemory memory)
{
    AEMU_SCOPED_TRACE("vkUnmapMemory");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkUnmapMemory(device, memory);
}
static VkResult entry_vkFlushMappedMemoryRanges(
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
    AEMU_SCOPED_TRACE("vkFlushMappedMemoryRanges");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
    vkFlushMappedMemoryRanges_VkResult_return = vkEnc->vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
    return vkFlushMappedMemoryRanges_VkResult_return;
}
static VkResult entry_vkInvalidateMappedMemoryRanges(
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
    AEMU_SCOPED_TRACE("vkInvalidateMappedMemoryRanges");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkInvalidateMappedMemoryRanges_VkResult_return = (VkResult)0;
    vkInvalidateMappedMemoryRanges_VkResult_return = vkEnc->vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
    return vkInvalidateMappedMemoryRanges_VkResult_return;
}
static void entry_vkGetDeviceMemoryCommitment(
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize* pCommittedMemoryInBytes)
{
    AEMU_SCOPED_TRACE("vkGetDeviceMemoryCommitment");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
}
static VkResult entry_vkBindBufferMemory(
    VkDevice device,
    VkBuffer buffer,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
    AEMU_SCOPED_TRACE("vkBindBufferMemory");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkBindBufferMemory_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindBufferMemory_VkResult_return = resources->on_vkBindBufferMemory(vkEnc, VK_SUCCESS, device, buffer, memory, memoryOffset);
    return vkBindBufferMemory_VkResult_return;
}
static VkResult entry_vkBindImageMemory(
    VkDevice device,
    VkImage image,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
    AEMU_SCOPED_TRACE("vkBindImageMemory");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkBindImageMemory_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindImageMemory_VkResult_return = resources->on_vkBindImageMemory(vkEnc, VK_SUCCESS, device, image, memory, memoryOffset);
    return vkBindImageMemory_VkResult_return;
}
static void entry_vkGetBufferMemoryRequirements(
    VkDevice device,
    VkBuffer buffer,
    VkMemoryRequirements* pMemoryRequirements)
{
    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetBufferMemoryRequirements(vkEnc, device, buffer, pMemoryRequirements);
}
static void entry_vkGetImageMemoryRequirements(
    VkDevice device,
    VkImage image,
    VkMemoryRequirements* pMemoryRequirements)
{
    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetImageMemoryRequirements(vkEnc, device, image, pMemoryRequirements);
}
static void entry_vkGetImageSparseMemoryRequirements(
    VkDevice device,
    VkImage image,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkSampleCountFlagBits samples,
    VkImageUsageFlags usage,
    VkImageTiling tiling,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties* pProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
}
static VkResult entry_vkQueueBindSparse(
    VkQueue queue,
    uint32_t bindInfoCount,
    const VkBindSparseInfo* pBindInfo,
    VkFence fence)
{
    AEMU_SCOPED_TRACE("vkQueueBindSparse");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkQueueBindSparse_VkResult_return = (VkResult)0;
    vkQueueBindSparse_VkResult_return = vkEnc->vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
    return vkQueueBindSparse_VkResult_return;
}
static VkResult entry_vkCreateFence(
    VkDevice device,
    const VkFenceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    AEMU_SCOPED_TRACE("vkCreateFence");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateFence_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateFence_VkResult_return = resources->on_vkCreateFence(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pFence);
    return vkCreateFence_VkResult_return;
}
static void entry_vkDestroyFence(
    VkDevice device,
    VkFence fence,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyFence");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyFence(device, fence, pAllocator);
}
static VkResult entry_vkResetFences(
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences)
{
    AEMU_SCOPED_TRACE("vkResetFences");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkResetFences_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkResetFences_VkResult_return = resources->on_vkResetFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences);
    return vkResetFences_VkResult_return;
}
static VkResult entry_vkGetFenceStatus(
    VkDevice device,
    VkFence fence)
{
    AEMU_SCOPED_TRACE("vkGetFenceStatus");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetFenceStatus_VkResult_return = (VkResult)0;
    vkGetFenceStatus_VkResult_return = vkEnc->vkGetFenceStatus(device, fence);
    return vkGetFenceStatus_VkResult_return;
}
static VkResult entry_vkWaitForFences(
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences,
    VkBool32 waitAll,
    uint64_t timeout)
{
    AEMU_SCOPED_TRACE("vkWaitForFences");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkWaitForFences_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkWaitForFences_VkResult_return = resources->on_vkWaitForFences(vkEnc, VK_SUCCESS, device, fenceCount, pFences, waitAll, timeout);
    return vkWaitForFences_VkResult_return;
}
static VkResult entry_vkCreateSemaphore(
    VkDevice device,
    const VkSemaphoreCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSemaphore* pSemaphore)
{
    AEMU_SCOPED_TRACE("vkCreateSemaphore");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateSemaphore_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateSemaphore_VkResult_return = resources->on_vkCreateSemaphore(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSemaphore);
    return vkCreateSemaphore_VkResult_return;
}
static void entry_vkDestroySemaphore(
    VkDevice device,
    VkSemaphore semaphore,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroySemaphore");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroySemaphore(vkEnc, device, semaphore, pAllocator);
}
static VkResult entry_vkCreateEvent(
    VkDevice device,
    const VkEventCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkEvent* pEvent)
{
    AEMU_SCOPED_TRACE("vkCreateEvent");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateEvent_VkResult_return = (VkResult)0;
    vkCreateEvent_VkResult_return = vkEnc->vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
    return vkCreateEvent_VkResult_return;
}
static void entry_vkDestroyEvent(
    VkDevice device,
    VkEvent event,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyEvent");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyEvent(device, event, pAllocator);
}
static VkResult entry_vkGetEventStatus(
    VkDevice device,
    VkEvent event)
{
    AEMU_SCOPED_TRACE("vkGetEventStatus");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetEventStatus_VkResult_return = (VkResult)0;
    vkGetEventStatus_VkResult_return = vkEnc->vkGetEventStatus(device, event);
    return vkGetEventStatus_VkResult_return;
}
static VkResult entry_vkSetEvent(
    VkDevice device,
    VkEvent event)
{
    AEMU_SCOPED_TRACE("vkSetEvent");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkSetEvent_VkResult_return = (VkResult)0;
    vkSetEvent_VkResult_return = vkEnc->vkSetEvent(device, event);
    return vkSetEvent_VkResult_return;
}
static VkResult entry_vkResetEvent(
    VkDevice device,
    VkEvent event)
{
    AEMU_SCOPED_TRACE("vkResetEvent");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkResetEvent_VkResult_return = (VkResult)0;
    vkResetEvent_VkResult_return = vkEnc->vkResetEvent(device, event);
    return vkResetEvent_VkResult_return;
}
static VkResult entry_vkCreateQueryPool(
    VkDevice device,
    const VkQueryPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkQueryPool* pQueryPool)
{
    AEMU_SCOPED_TRACE("vkCreateQueryPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateQueryPool_VkResult_return = (VkResult)0;
    vkCreateQueryPool_VkResult_return = vkEnc->vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
    return vkCreateQueryPool_VkResult_return;
}
static void entry_vkDestroyQueryPool(
    VkDevice device,
    VkQueryPool queryPool,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyQueryPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyQueryPool(device, queryPool, pAllocator);
}
static VkResult entry_vkGetQueryPoolResults(
    VkDevice device,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    size_t dataSize,
    void* pData,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
    AEMU_SCOPED_TRACE("vkGetQueryPoolResults");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetQueryPoolResults_VkResult_return = (VkResult)0;
    vkGetQueryPoolResults_VkResult_return = vkEnc->vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
    return vkGetQueryPoolResults_VkResult_return;
}
static VkResult entry_vkCreateBuffer(
    VkDevice device,
    const VkBufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer)
{
    AEMU_SCOPED_TRACE("vkCreateBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateBuffer_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateBuffer_VkResult_return = resources->on_vkCreateBuffer(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pBuffer);
    return vkCreateBuffer_VkResult_return;
}
static void entry_vkDestroyBuffer(
    VkDevice device,
    VkBuffer buffer,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroyBuffer(vkEnc, device, buffer, pAllocator);
}
static VkResult entry_vkCreateBufferView(
    VkDevice device,
    const VkBufferViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBufferView* pView)
{
    AEMU_SCOPED_TRACE("vkCreateBufferView");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateBufferView_VkResult_return = (VkResult)0;
    vkCreateBufferView_VkResult_return = vkEnc->vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
    return vkCreateBufferView_VkResult_return;
}
static void entry_vkDestroyBufferView(
    VkDevice device,
    VkBufferView bufferView,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyBufferView");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyBufferView(device, bufferView, pAllocator);
}
static VkResult entry_vkCreateImage(
    VkDevice device,
    const VkImageCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImage* pImage)
{
    AEMU_SCOPED_TRACE("vkCreateImage");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateImage_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateImage_VkResult_return = resources->on_vkCreateImage(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pImage);
    return vkCreateImage_VkResult_return;
}
static void entry_vkDestroyImage(
    VkDevice device,
    VkImage image,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyImage");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroyImage(vkEnc, device, image, pAllocator);
}
static void entry_vkGetImageSubresourceLayout(
    VkDevice device,
    VkImage image,
    const VkImageSubresource* pSubresource,
    VkSubresourceLayout* pLayout)
{
    AEMU_SCOPED_TRACE("vkGetImageSubresourceLayout");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetImageSubresourceLayout(device, image, pSubresource, pLayout);
}
static VkResult entry_vkCreateImageView(
    VkDevice device,
    const VkImageViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImageView* pView)
{
    AEMU_SCOPED_TRACE("vkCreateImageView");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateImageView_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateImageView_VkResult_return = resources->on_vkCreateImageView(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pView);
    return vkCreateImageView_VkResult_return;
}
static void entry_vkDestroyImageView(
    VkDevice device,
    VkImageView imageView,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyImageView");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyImageView(device, imageView, pAllocator);
}
static VkResult entry_vkCreateShaderModule(
    VkDevice device,
    const VkShaderModuleCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkShaderModule* pShaderModule)
{
    AEMU_SCOPED_TRACE("vkCreateShaderModule");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateShaderModule_VkResult_return = (VkResult)0;
    vkCreateShaderModule_VkResult_return = vkEnc->vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
    return vkCreateShaderModule_VkResult_return;
}
static void entry_vkDestroyShaderModule(
    VkDevice device,
    VkShaderModule shaderModule,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyShaderModule");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyShaderModule(device, shaderModule, pAllocator);
}
static VkResult entry_vkCreatePipelineCache(
    VkDevice device,
    const VkPipelineCacheCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineCache* pPipelineCache)
{
    AEMU_SCOPED_TRACE("vkCreatePipelineCache");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreatePipelineCache_VkResult_return = (VkResult)0;
    vkCreatePipelineCache_VkResult_return = vkEnc->vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
    return vkCreatePipelineCache_VkResult_return;
}
static void entry_vkDestroyPipelineCache(
    VkDevice device,
    VkPipelineCache pipelineCache,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyPipelineCache");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyPipelineCache(device, pipelineCache, pAllocator);
}
static VkResult entry_vkGetPipelineCacheData(
    VkDevice device,
    VkPipelineCache pipelineCache,
    size_t* pDataSize,
    void* pData)
{
    AEMU_SCOPED_TRACE("vkGetPipelineCacheData");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPipelineCacheData_VkResult_return = (VkResult)0;
    vkGetPipelineCacheData_VkResult_return = vkEnc->vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
    return vkGetPipelineCacheData_VkResult_return;
}
static VkResult entry_vkMergePipelineCaches(
    VkDevice device,
    VkPipelineCache dstCache,
    uint32_t srcCacheCount,
    const VkPipelineCache* pSrcCaches)
{
    AEMU_SCOPED_TRACE("vkMergePipelineCaches");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkMergePipelineCaches_VkResult_return = (VkResult)0;
    vkMergePipelineCaches_VkResult_return = vkEnc->vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
    return vkMergePipelineCaches_VkResult_return;
}
static VkResult entry_vkCreateGraphicsPipelines(
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkGraphicsPipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
    AEMU_SCOPED_TRACE("vkCreateGraphicsPipelines");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateGraphicsPipelines_VkResult_return = (VkResult)0;
    vkCreateGraphicsPipelines_VkResult_return = vkEnc->vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    return vkCreateGraphicsPipelines_VkResult_return;
}
static VkResult entry_vkCreateComputePipelines(
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkComputePipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
    AEMU_SCOPED_TRACE("vkCreateComputePipelines");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateComputePipelines_VkResult_return = (VkResult)0;
    vkCreateComputePipelines_VkResult_return = vkEnc->vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
    return vkCreateComputePipelines_VkResult_return;
}
static void entry_vkDestroyPipeline(
    VkDevice device,
    VkPipeline pipeline,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyPipeline");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyPipeline(device, pipeline, pAllocator);
}
static VkResult entry_vkCreatePipelineLayout(
    VkDevice device,
    const VkPipelineLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineLayout* pPipelineLayout)
{
    AEMU_SCOPED_TRACE("vkCreatePipelineLayout");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreatePipelineLayout_VkResult_return = (VkResult)0;
    vkCreatePipelineLayout_VkResult_return = vkEnc->vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
    return vkCreatePipelineLayout_VkResult_return;
}
static void entry_vkDestroyPipelineLayout(
    VkDevice device,
    VkPipelineLayout pipelineLayout,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyPipelineLayout");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
}
static VkResult entry_vkCreateSampler(
    VkDevice device,
    const VkSamplerCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSampler* pSampler)
{
    AEMU_SCOPED_TRACE("vkCreateSampler");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateSampler_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateSampler_VkResult_return = resources->on_vkCreateSampler(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSampler);
    return vkCreateSampler_VkResult_return;
}
static void entry_vkDestroySampler(
    VkDevice device,
    VkSampler sampler,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroySampler");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroySampler(device, sampler, pAllocator);
}
static VkResult entry_vkCreateDescriptorSetLayout(
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorSetLayout* pSetLayout)
{
    AEMU_SCOPED_TRACE("vkCreateDescriptorSetLayout");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateDescriptorSetLayout_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateDescriptorSetLayout_VkResult_return = resources->on_vkCreateDescriptorSetLayout(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pSetLayout);
    return vkCreateDescriptorSetLayout_VkResult_return;
}
static void entry_vkDestroyDescriptorSetLayout(
    VkDevice device,
    VkDescriptorSetLayout descriptorSetLayout,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyDescriptorSetLayout");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
}
static VkResult entry_vkCreateDescriptorPool(
    VkDevice device,
    const VkDescriptorPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorPool* pDescriptorPool)
{
    AEMU_SCOPED_TRACE("vkCreateDescriptorPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateDescriptorPool_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateDescriptorPool_VkResult_return = resources->on_vkCreateDescriptorPool(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pDescriptorPool);
    return vkCreateDescriptorPool_VkResult_return;
}
static void entry_vkDestroyDescriptorPool(
    VkDevice device,
    VkDescriptorPool descriptorPool,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyDescriptorPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkDestroyDescriptorPool(vkEnc, device, descriptorPool, pAllocator);
}
static VkResult entry_vkResetDescriptorPool(
    VkDevice device,
    VkDescriptorPool descriptorPool,
    VkDescriptorPoolResetFlags flags)
{
    AEMU_SCOPED_TRACE("vkResetDescriptorPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkResetDescriptorPool_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkResetDescriptorPool_VkResult_return = resources->on_vkResetDescriptorPool(vkEnc, VK_SUCCESS, device, descriptorPool, flags);
    return vkResetDescriptorPool_VkResult_return;
}
static VkResult entry_vkAllocateDescriptorSets(
    VkDevice device,
    const VkDescriptorSetAllocateInfo* pAllocateInfo,
    VkDescriptorSet* pDescriptorSets)
{
    AEMU_SCOPED_TRACE("vkAllocateDescriptorSets");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkAllocateDescriptorSets_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkAllocateDescriptorSets_VkResult_return = resources->on_vkAllocateDescriptorSets(vkEnc, VK_SUCCESS, device, pAllocateInfo, pDescriptorSets);
    return vkAllocateDescriptorSets_VkResult_return;
}
static VkResult entry_vkFreeDescriptorSets(
    VkDevice device,
    VkDescriptorPool descriptorPool,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets)
{
    AEMU_SCOPED_TRACE("vkFreeDescriptorSets");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkFreeDescriptorSets_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkFreeDescriptorSets_VkResult_return = resources->on_vkFreeDescriptorSets(vkEnc, VK_SUCCESS, device, descriptorPool, descriptorSetCount, pDescriptorSets);
    return vkFreeDescriptorSets_VkResult_return;
}
static void entry_vkUpdateDescriptorSets(
    VkDevice device,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites,
    uint32_t descriptorCopyCount,
    const VkCopyDescriptorSet* pDescriptorCopies)
{
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSets");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkUpdateDescriptorSets(vkEnc, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
}
static VkResult entry_vkCreateFramebuffer(
    VkDevice device,
    const VkFramebufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFramebuffer* pFramebuffer)
{
    AEMU_SCOPED_TRACE("vkCreateFramebuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateFramebuffer_VkResult_return = (VkResult)0;
    vkCreateFramebuffer_VkResult_return = vkEnc->vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
    return vkCreateFramebuffer_VkResult_return;
}
static void entry_vkDestroyFramebuffer(
    VkDevice device,
    VkFramebuffer framebuffer,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyFramebuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyFramebuffer(device, framebuffer, pAllocator);
}
static VkResult entry_vkCreateRenderPass(
    VkDevice device,
    const VkRenderPassCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
    AEMU_SCOPED_TRACE("vkCreateRenderPass");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateRenderPass_VkResult_return = (VkResult)0;
    vkCreateRenderPass_VkResult_return = vkEnc->vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
    return vkCreateRenderPass_VkResult_return;
}
static void entry_vkDestroyRenderPass(
    VkDevice device,
    VkRenderPass renderPass,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyRenderPass");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyRenderPass(device, renderPass, pAllocator);
}
static void entry_vkGetRenderAreaGranularity(
    VkDevice device,
    VkRenderPass renderPass,
    VkExtent2D* pGranularity)
{
    AEMU_SCOPED_TRACE("vkGetRenderAreaGranularity");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetRenderAreaGranularity(device, renderPass, pGranularity);
}
static VkResult entry_vkCreateCommandPool(
    VkDevice device,
    const VkCommandPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkCommandPool* pCommandPool)
{
    AEMU_SCOPED_TRACE("vkCreateCommandPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateCommandPool_VkResult_return = (VkResult)0;
    vkCreateCommandPool_VkResult_return = vkEnc->vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
    return vkCreateCommandPool_VkResult_return;
}
static void entry_vkDestroyCommandPool(
    VkDevice device,
    VkCommandPool commandPool,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyCommandPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroyCommandPool(device, commandPool, pAllocator);
}
static VkResult entry_vkResetCommandPool(
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolResetFlags flags)
{
    AEMU_SCOPED_TRACE("vkResetCommandPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkResetCommandPool_VkResult_return = (VkResult)0;
    vkResetCommandPool_VkResult_return = vkEnc->vkResetCommandPool(device, commandPool, flags);
    return vkResetCommandPool_VkResult_return;
}
static VkResult entry_vkAllocateCommandBuffers(
    VkDevice device,
    const VkCommandBufferAllocateInfo* pAllocateInfo,
    VkCommandBuffer* pCommandBuffers)
{
    AEMU_SCOPED_TRACE("vkAllocateCommandBuffers");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkAllocateCommandBuffers_VkResult_return = (VkResult)0;
    vkAllocateCommandBuffers_VkResult_return = vkEnc->vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
    return vkAllocateCommandBuffers_VkResult_return;
}
static void entry_vkFreeCommandBuffers(
    VkDevice device,
    VkCommandPool commandPool,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
    AEMU_SCOPED_TRACE("vkFreeCommandBuffers");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
}
static VkResult entry_vkBeginCommandBuffer(
    VkCommandBuffer commandBuffer,
    const VkCommandBufferBeginInfo* pBeginInfo)
{
    AEMU_SCOPED_TRACE("vkBeginCommandBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    VkResult vkBeginCommandBuffer_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBeginCommandBuffer_VkResult_return = resources->on_vkBeginCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, pBeginInfo);
    return vkBeginCommandBuffer_VkResult_return;
}
static VkResult entry_vkEndCommandBuffer(
    VkCommandBuffer commandBuffer)
{
    AEMU_SCOPED_TRACE("vkEndCommandBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    VkResult vkEndCommandBuffer_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkEndCommandBuffer_VkResult_return = resources->on_vkEndCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer);
    return vkEndCommandBuffer_VkResult_return;
}
static VkResult entry_vkResetCommandBuffer(
    VkCommandBuffer commandBuffer,
    VkCommandBufferResetFlags flags)
{
    AEMU_SCOPED_TRACE("vkResetCommandBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    VkResult vkResetCommandBuffer_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkResetCommandBuffer_VkResult_return = resources->on_vkResetCommandBuffer(vkEnc, VK_SUCCESS, commandBuffer, flags);
    return vkResetCommandBuffer_VkResult_return;
}
static void entry_vkCmdBindPipeline(
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipeline pipeline)
{
    AEMU_SCOPED_TRACE("vkCmdBindPipeline");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}
static void entry_vkCmdSetViewport(
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewport* pViewports)
{
    AEMU_SCOPED_TRACE("vkCmdSetViewport");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
}
static void entry_vkCmdSetScissor(
    VkCommandBuffer commandBuffer,
    uint32_t firstScissor,
    uint32_t scissorCount,
    const VkRect2D* pScissors)
{
    AEMU_SCOPED_TRACE("vkCmdSetScissor");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
}
static void entry_vkCmdSetLineWidth(
    VkCommandBuffer commandBuffer,
    float lineWidth)
{
    AEMU_SCOPED_TRACE("vkCmdSetLineWidth");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetLineWidth(commandBuffer, lineWidth);
}
static void entry_vkCmdSetDepthBias(
    VkCommandBuffer commandBuffer,
    float depthBiasConstantFactor,
    float depthBiasClamp,
    float depthBiasSlopeFactor)
{
    AEMU_SCOPED_TRACE("vkCmdSetDepthBias");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
static void entry_vkCmdSetBlendConstants(
    VkCommandBuffer commandBuffer,
    const float blendConstants[4])
{
    AEMU_SCOPED_TRACE("vkCmdSetBlendConstants");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetBlendConstants(commandBuffer, blendConstants);
}
static void entry_vkCmdSetDepthBounds(
    VkCommandBuffer commandBuffer,
    float minDepthBounds,
    float maxDepthBounds)
{
    AEMU_SCOPED_TRACE("vkCmdSetDepthBounds");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
}
static void entry_vkCmdSetStencilCompareMask(
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t compareMask)
{
    AEMU_SCOPED_TRACE("vkCmdSetStencilCompareMask");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
}
static void entry_vkCmdSetStencilWriteMask(
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t writeMask)
{
    AEMU_SCOPED_TRACE("vkCmdSetStencilWriteMask");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
}
static void entry_vkCmdSetStencilReference(
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t reference)
{
    AEMU_SCOPED_TRACE("vkCmdSetStencilReference");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetStencilReference(commandBuffer, faceMask, reference);
}
static void entry_vkCmdBindDescriptorSets(
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t firstSet,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets,
    uint32_t dynamicOffsetCount,
    const uint32_t* pDynamicOffsets)
{
    AEMU_SCOPED_TRACE("vkCmdBindDescriptorSets");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
static void entry_vkCmdBindIndexBuffer(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkIndexType indexType)
{
    AEMU_SCOPED_TRACE("vkCmdBindIndexBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
}
static void entry_vkCmdBindVertexBuffers(
    VkCommandBuffer commandBuffer,
    uint32_t firstBinding,
    uint32_t bindingCount,
    const VkBuffer* pBuffers,
    const VkDeviceSize* pOffsets)
{
    AEMU_SCOPED_TRACE("vkCmdBindVertexBuffers");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}
static void entry_vkCmdDraw(
    VkCommandBuffer commandBuffer,
    uint32_t vertexCount,
    uint32_t instanceCount,
    uint32_t firstVertex,
    uint32_t firstInstance)
{
    AEMU_SCOPED_TRACE("vkCmdDraw");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
static void entry_vkCmdDrawIndexed(
    VkCommandBuffer commandBuffer,
    uint32_t indexCount,
    uint32_t instanceCount,
    uint32_t firstIndex,
    int32_t vertexOffset,
    uint32_t firstInstance)
{
    AEMU_SCOPED_TRACE("vkCmdDrawIndexed");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
static void entry_vkCmdDrawIndirect(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
    AEMU_SCOPED_TRACE("vkCmdDrawIndirect");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
}
static void entry_vkCmdDrawIndexedIndirect(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
    AEMU_SCOPED_TRACE("vkCmdDrawIndexedIndirect");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
}
static void entry_vkCmdDispatch(
    VkCommandBuffer commandBuffer,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    AEMU_SCOPED_TRACE("vkCmdDispatch");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
}
static void entry_vkCmdDispatchIndirect(
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset)
{
    AEMU_SCOPED_TRACE("vkCmdDispatchIndirect");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdDispatchIndirect(commandBuffer, buffer, offset);
}
static void entry_vkCmdCopyBuffer(
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferCopy* pRegions)
{
    AEMU_SCOPED_TRACE("vkCmdCopyBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
static void entry_vkCmdCopyImage(
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageCopy* pRegions)
{
    AEMU_SCOPED_TRACE("vkCmdCopyImage");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
static void entry_vkCmdBlitImage(
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageBlit* pRegions,
    VkFilter filter)
{
    AEMU_SCOPED_TRACE("vkCmdBlitImage");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
static void entry_vkCmdCopyBufferToImage(
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
    AEMU_SCOPED_TRACE("vkCmdCopyBufferToImage");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
static void entry_vkCmdCopyImageToBuffer(
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
    AEMU_SCOPED_TRACE("vkCmdCopyImageToBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
static void entry_vkCmdUpdateBuffer(
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize dataSize,
    const void* pData)
{
    AEMU_SCOPED_TRACE("vkCmdUpdateBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
static void entry_vkCmdFillBuffer(
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize size,
    uint32_t data)
{
    AEMU_SCOPED_TRACE("vkCmdFillBuffer");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
static void entry_vkCmdClearColorImage(
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearColorValue* pColor,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
    AEMU_SCOPED_TRACE("vkCmdClearColorImage");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
static void entry_vkCmdClearDepthStencilImage(
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearDepthStencilValue* pDepthStencil,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
    AEMU_SCOPED_TRACE("vkCmdClearDepthStencilImage");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
static void entry_vkCmdClearAttachments(
    VkCommandBuffer commandBuffer,
    uint32_t attachmentCount,
    const VkClearAttachment* pAttachments,
    uint32_t rectCount,
    const VkClearRect* pRects)
{
    AEMU_SCOPED_TRACE("vkCmdClearAttachments");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
static void entry_vkCmdResolveImage(
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageResolve* pRegions)
{
    AEMU_SCOPED_TRACE("vkCmdResolveImage");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
static void entry_vkCmdSetEvent(
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
    AEMU_SCOPED_TRACE("vkCmdSetEvent");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetEvent(commandBuffer, event, stageMask);
}
static void entry_vkCmdResetEvent(
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
    AEMU_SCOPED_TRACE("vkCmdResetEvent");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdResetEvent(commandBuffer, event, stageMask);
}
static void entry_vkCmdWaitEvents(
    VkCommandBuffer commandBuffer,
    uint32_t eventCount,
    const VkEvent* pEvents,
    VkPipelineStageFlags srcStageMask,
    VkPipelineStageFlags dstStageMask,
    uint32_t memoryBarrierCount,
    const VkMemoryBarrier* pMemoryBarriers,
    uint32_t bufferMemoryBarrierCount,
    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
    uint32_t imageMemoryBarrierCount,
    const VkImageMemoryBarrier* pImageMemoryBarriers)
{
    AEMU_SCOPED_TRACE("vkCmdWaitEvents");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
static void entry_vkCmdPipelineBarrier(
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlags srcStageMask,
    VkPipelineStageFlags dstStageMask,
    VkDependencyFlags dependencyFlags,
    uint32_t memoryBarrierCount,
    const VkMemoryBarrier* pMemoryBarriers,
    uint32_t bufferMemoryBarrierCount,
    const VkBufferMemoryBarrier* pBufferMemoryBarriers,
    uint32_t imageMemoryBarrierCount,
    const VkImageMemoryBarrier* pImageMemoryBarriers)
{
    AEMU_SCOPED_TRACE("vkCmdPipelineBarrier");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
static void entry_vkCmdBeginQuery(
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query,
    VkQueryControlFlags flags)
{
    AEMU_SCOPED_TRACE("vkCmdBeginQuery");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdBeginQuery(commandBuffer, queryPool, query, flags);
}
static void entry_vkCmdEndQuery(
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query)
{
    AEMU_SCOPED_TRACE("vkCmdEndQuery");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdEndQuery(commandBuffer, queryPool, query);
}
static void entry_vkCmdResetQueryPool(
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount)
{
    AEMU_SCOPED_TRACE("vkCmdResetQueryPool");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
}
static void entry_vkCmdWriteTimestamp(
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkQueryPool queryPool,
    uint32_t query)
{
    AEMU_SCOPED_TRACE("vkCmdWriteTimestamp");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
}
static void entry_vkCmdCopyQueryPoolResults(
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
    AEMU_SCOPED_TRACE("vkCmdCopyQueryPoolResults");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
static void entry_vkCmdPushConstants(
    VkCommandBuffer commandBuffer,
    VkPipelineLayout layout,
    VkShaderStageFlags stageFlags,
    uint32_t offset,
    uint32_t size,
    const void* pValues)
{
    AEMU_SCOPED_TRACE("vkCmdPushConstants");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
}
static void entry_vkCmdBeginRenderPass(
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    VkSubpassContents contents)
{
    AEMU_SCOPED_TRACE("vkCmdBeginRenderPass");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
}
static void entry_vkCmdNextSubpass(
    VkCommandBuffer commandBuffer,
    VkSubpassContents contents)
{
    AEMU_SCOPED_TRACE("vkCmdNextSubpass");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdNextSubpass(commandBuffer, contents);
}
static void entry_vkCmdEndRenderPass(
    VkCommandBuffer commandBuffer)
{
    AEMU_SCOPED_TRACE("vkCmdEndRenderPass");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdEndRenderPass(commandBuffer);
}
static void entry_vkCmdExecuteCommands(
    VkCommandBuffer commandBuffer,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
    AEMU_SCOPED_TRACE("vkCmdExecuteCommands");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
}
#endif
#ifdef VK_VERSION_1_1
static VkResult entry_vkEnumerateInstanceVersion(
    uint32_t* pApiVersion)
{
    AEMU_SCOPED_TRACE("vkEnumerateInstanceVersion");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkEnumerateInstanceVersion_VkResult_return = (VkResult)0;
    vkEnumerateInstanceVersion_VkResult_return = vkEnc->vkEnumerateInstanceVersion(pApiVersion);
    return vkEnumerateInstanceVersion_VkResult_return;
}
static VkResult entry_vkBindBufferMemory2(
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
    AEMU_SCOPED_TRACE("vkBindBufferMemory2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkBindBufferMemory2_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindBufferMemory2_VkResult_return = resources->on_vkBindBufferMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindBufferMemory2_VkResult_return;
}
static VkResult dynCheck_entry_vkBindBufferMemory2(
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
    {
        sOnInvalidDynamicallyCheckedCall("vkBindBufferMemory2", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkBindBufferMemory2");
    auto vkEnc = 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,
    const VkBindImageMemoryInfo* pBindInfos)
{
    AEMU_SCOPED_TRACE("vkBindImageMemory2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkBindImageMemory2_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkBindImageMemory2_VkResult_return = resources->on_vkBindImageMemory2(vkEnc, VK_SUCCESS, device, bindInfoCount, pBindInfos);
    return vkBindImageMemory2_VkResult_return;
}
static VkResult dynCheck_entry_vkBindImageMemory2(
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
    {
        sOnInvalidDynamicallyCheckedCall("vkBindImageMemory2", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkBindImageMemory2");
    auto vkEnc = 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,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    AEMU_SCOPED_TRACE("vkGetDeviceGroupPeerMemoryFeatures");
    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)
{
    AEMU_SCOPED_TRACE("vkCmdSetDeviceMask");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdSetDeviceMask(commandBuffer, deviceMask);
}
static void entry_vkCmdDispatchBase(
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    AEMU_SCOPED_TRACE("vkCmdDispatchBase");
    auto vkEnc = HostConnection::get()->vkEncoder();
    ResourceTracker::get()->syncEncodersForCommandBuffer(commandBuffer, vkEnc);
    vkEnc->vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
static VkResult entry_vkEnumeratePhysicalDeviceGroups(
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    AEMU_SCOPED_TRACE("vkEnumeratePhysicalDeviceGroups");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkEnumeratePhysicalDeviceGroups_VkResult_return = (VkResult)0;
    vkEnumeratePhysicalDeviceGroups_VkResult_return = vkEnc->vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
    return vkEnumeratePhysicalDeviceGroups_VkResult_return;
}
static void entry_vkGetImageMemoryRequirements2(
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    AEMU_SCOPED_TRACE("vkGetImageMemoryRequirements2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    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,
    VkMemoryRequirements2* pMemoryRequirements)
{
    AEMU_SCOPED_TRACE("vkGetBufferMemoryRequirements2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    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,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    AEMU_SCOPED_TRACE("vkGetImageSparseMemoryRequirements2");
    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)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFeatures2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures);
}
static void entry_vkGetPhysicalDeviceProperties2(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceProperties2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceProperties2(physicalDevice, pProperties);
}
static void entry_vkGetPhysicalDeviceFormatProperties2(
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceFormatProperties2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
}
static VkResult entry_vkGetPhysicalDeviceImageFormatProperties2(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceImageFormatProperties2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkGetPhysicalDeviceImageFormatProperties2_VkResult_return = resources->on_vkGetPhysicalDeviceImageFormatProperties2(vkEnc, VK_SUCCESS, physicalDevice, pImageFormatInfo, pImageFormatProperties);
    return vkGetPhysicalDeviceImageFormatProperties2_VkResult_return;
}
static void entry_vkGetPhysicalDeviceQueueFamilyProperties2(
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceQueueFamilyProperties2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
static void entry_vkGetPhysicalDeviceMemoryProperties2(
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceMemoryProperties2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
}
static void entry_vkGetPhysicalDeviceSparseImageFormatProperties2(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSparseImageFormatProperties2");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}
static void entry_vkTrimCommandPool(
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
    AEMU_SCOPED_TRACE("vkTrimCommandPool");
    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,
    VkQueue* pQueue)
{
    AEMU_SCOPED_TRACE("vkGetDeviceQueue2");
    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,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateSamplerYcbcrConversion_VkResult_return = (VkResult)0;
    auto resources = ResourceTracker::get();
    vkCreateSamplerYcbcrConversion_VkResult_return = resources->on_vkCreateSamplerYcbcrConversion(vkEnc, VK_SUCCESS, device, pCreateInfo, pAllocator, pYcbcrConversion);
    return vkCreateSamplerYcbcrConversion_VkResult_return;
}
static VkResult dynCheck_entry_vkCreateSamplerYcbcrConversion(
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
    auto resources = ResourceTracker::get();
    if (resources->getApiVersionFromDevice(device) < VK_API_VERSION_1_1)
    {
        sOnInvalidDynamicallyCheckedCall("vkCreateSamplerYcbcrConversion", "VK_VERSION_1_1");
    }
    AEMU_SCOPED_TRACE("vkCreateSamplerYcbcrConversion");
    auto vkEnc = 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,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroySamplerYcbcrConversion");
    auto vkEnc = HostConnection::get()->vkEncoder();
    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,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    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 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,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroyDescriptorUpdateTemplate");
    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,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
    AEMU_SCOPED_TRACE("vkUpdateDescriptorSetWithTemplate");
    auto vkEnc = HostConnection::get()->vkEncoder();
    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,
    VkExternalBufferProperties* pExternalBufferProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalBufferProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
static void entry_vkGetPhysicalDeviceExternalFenceProperties(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalFenceProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    auto resources = ResourceTracker::get();
    resources->on_vkGetPhysicalDeviceExternalFenceProperties(vkEnc, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
static void entry_vkGetPhysicalDeviceExternalSemaphoreProperties(
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceExternalSemaphoreProperties");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
}
static void entry_vkGetDescriptorSetLayoutSupport(
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
    AEMU_SCOPED_TRACE("vkGetDescriptorSetLayoutSupport");
    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(
    VkInstance instance,
    VkSurfaceKHR surface,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroySurfaceKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    vkEnc->vkDestroySurfaceKHR(instance, surface, pAllocator);
}
static VkResult entry_vkGetPhysicalDeviceSurfaceSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    VkSurfaceKHR surface,
    VkBool32* pSupported)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceSupportKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
    return vkGetPhysicalDeviceSurfaceSupportKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
    return vkGetPhysicalDeviceSurfaceCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfaceFormatsKHR(
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormatKHR* pSurfaceFormats)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfaceFormatsKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
    return vkGetPhysicalDeviceSurfaceFormatsKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceSurfacePresentModesKHR(
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pPresentModeCount,
    VkPresentModeKHR* pPresentModes)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceSurfacePresentModesKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
    return vkGetPhysicalDeviceSurfacePresentModesKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_swapchain
static VkResult entry_vkCreateSwapchainKHR(
    VkDevice device,
    const VkSwapchainCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchain)
{
    AEMU_SCOPED_TRACE("vkCreateSwapchainKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateSwapchainKHR_VkResult_return = (VkResult)0;
    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,
    const VkAllocationCallbacks* pAllocator)
{
    AEMU_SCOPED_TRACE("vkDestroySwapchainKHR");
    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,
    uint32_t* pSwapchainImageCount,
    VkImage* pSwapchainImages)
{
    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 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,
    uint64_t timeout,
    VkSemaphore semaphore,
    VkFence fence,
    uint32_t* pImageIndex)
{
    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 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)
{
    AEMU_SCOPED_TRACE("vkQueuePresentKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkQueuePresentKHR_VkResult_return = (VkResult)0;
    vkQueuePresentKHR_VkResult_return = vkEnc->vkQueuePresentKHR(queue, pPresentInfo);
    return vkQueuePresentKHR_VkResult_return;
}
static VkResult entry_vkGetDeviceGroupPresentCapabilitiesKHR(
    VkDevice device,
    VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
    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 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,
    VkDeviceGroupPresentModeFlagsKHR* pModes)
{
    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 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,
    uint32_t* pRectCount,
    VkRect2D* pRects)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDevicePresentRectanglesKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = (VkResult)0;
    vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return = vkEnc->vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
    return vkGetPhysicalDevicePresentRectanglesKHR_VkResult_return;
}
static VkResult entry_vkAcquireNextImage2KHR(
    VkDevice device,
    const VkAcquireNextImageInfoKHR* pAcquireInfo,
    uint32_t* pImageIndex)
{
    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;
}
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(
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPropertiesKHR* pProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPropertiesKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
    return vkGetPhysicalDeviceDisplayPropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlanePropertiesKHR* pProperties)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = (VkResult)0;
    vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return = vkEnc->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
    return vkGetPhysicalDeviceDisplayPlanePropertiesKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayPlaneSupportedDisplaysKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t planeIndex,
    uint32_t* pDisplayCount,
    VkDisplayKHR* pDisplays)
{
    AEMU_SCOPED_TRACE("vkGetDisplayPlaneSupportedDisplaysKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = (VkResult)0;
    vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return = vkEnc->vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays);
    return vkGetDisplayPlaneSupportedDisplaysKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayModePropertiesKHR(
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModePropertiesKHR* pProperties)
{
    AEMU_SCOPED_TRACE("vkGetDisplayModePropertiesKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetDisplayModePropertiesKHR_VkResult_return = (VkResult)0;
    vkGetDisplayModePropertiesKHR_VkResult_return = vkEnc->vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
    return vkGetDisplayModePropertiesKHR_VkResult_return;
}
static VkResult entry_vkCreateDisplayModeKHR(
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    const VkDisplayModeCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDisplayModeKHR* pMode)
{
    AEMU_SCOPED_TRACE("vkCreateDisplayModeKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateDisplayModeKHR_VkResult_return = (VkResult)0;
    vkCreateDisplayModeKHR_VkResult_return = vkEnc->vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
    return vkCreateDisplayModeKHR_VkResult_return;
}
static VkResult entry_vkGetDisplayPlaneCapabilitiesKHR(
    VkPhysicalDevice physicalDevice,
    VkDisplayModeKHR mode,
    uint32_t planeIndex,
    VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
    AEMU_SCOPED_TRACE("vkGetDisplayPlaneCapabilitiesKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = (VkResult)0;
    vkGetDisplayPlaneCapabilitiesKHR_VkResult_return = vkEnc->vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
    return vkGetDisplayPlaneCapabilitiesKHR_VkResult_return;
}
static VkResult entry_vkCreateDisplayPlaneSurfaceKHR(
    VkInstance instance,
    const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    AEMU_SCOPED_TRACE("vkCreateDisplayPlaneSurfaceKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateDisplayPlaneSurfaceKHR_VkResult_return = (VkResult)0;
    vkCreateDisplayPlaneSurfaceKHR_VkResult_return = vkEnc->vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
    return vkCreateDisplayPlaneSurfaceKHR_VkResult_return;
}
#endif
#ifdef VK_KHR_display_swapchain
static VkResult entry_vkCreateSharedSwapchainsKHR(
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainCreateInfoKHR* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchains)
{
    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;
}
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(
    VkInstance instance,
    const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    AEMU_SCOPED_TRACE("vkCreateXlibSurfaceKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateXlibSurfaceKHR_VkResult_return = (VkResult)0;
    vkCreateXlibSurfaceKHR_VkResult_return = vkEnc->vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
    return vkCreateXlibSurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceXlibPresentationSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    Display* dpy,
    VisualID visualID)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXlibPresentationSupportKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = (VkBool32)0;
    vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID);
    return vkGetPhysicalDeviceXlibPresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_xcb_surface
static VkResult entry_vkCreateXcbSurfaceKHR(
    VkInstance instance,
    const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    AEMU_SCOPED_TRACE("vkCreateXcbSurfaceKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateXcbSurfaceKHR_VkResult_return = (VkResult)0;
    vkCreateXcbSurfaceKHR_VkResult_return = vkEnc->vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
    return vkCreateXcbSurfaceKHR_VkResult_return;
}
static VkBool32 entry_vkGetPhysicalDeviceXcbPresentationSupportKHR(
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    xcb_connection_t* connection,
    xcb_visualid_t visual_id)
{
    AEMU_SCOPED_TRACE("vkGetPhysicalDeviceXcbPresentationSupportKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = (VkBool32)0;
    vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return = vkEnc->vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id);
    return vkGetPhysicalDeviceXcbPresentationSupportKHR_VkBool32_return;
}
#endif
#ifdef VK_KHR_wayland_surface
static VkResult entry_vkCreateWaylandSurfaceKHR(
    VkInstance instance,
    const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    AEMU_SCOPED_TRACE("vkCreateWaylandSurfaceKHR");
    auto vkEnc = HostConnection::get()->vkEncoder();
    VkResult vkCreateWaylandSurfaceKHR_VkResult_return = (VkResult)0;
    vkCreateWaylandSurfaceKHR_VkResult_return = vkEnc->vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
    return vkCreateWaylandSurfaceKHR_VkResult_return;
}