// 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 VkDecoderSnapshot
// (impl) generated by protocols/vulkan/xml/genvk.py -registry protocols/vulkan/xml/vk.xml cereal -o stream-servers/vulkan/cereal
// Please do not modify directly;
// re-run 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 "VkDecoderSnapshot.h"


#include "VulkanHandleMapping.h"
#include "VkDecoderGlobalState.h"
#include "VkReconstruction.h"

#include "base/Lock.h"


using namespace goldfish_vk;

class VkDecoderSnapshot::Impl {
public:
    Impl() { }

    void save(android::base::Stream* stream) {
        mReconstruction.save(stream);
    }

    void load(android::base::Stream* stream) {
        mReconstruction.load(stream);
    }

#ifdef VK_VERSION_1_0
void vkCreateInstance(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    const VkInstanceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkInstance* pInstance)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pInstance create
    mReconstruction.addHandles((const uint64_t*)pInstance, 1);
    if (!pInstance) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateInstance, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pInstance, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pInstance, 1);
}
void vkDestroyInstance(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // instance destroy
    mReconstruction.removeHandles((const uint64_t*)(&instance), 1);
}
void vkEnumeratePhysicalDevices(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    uint32_t* pPhysicalDeviceCount,
    VkPhysicalDevice* pPhysicalDevices)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pPhysicalDevices create
    mReconstruction.addHandles((const uint64_t*)pPhysicalDevices, (*(pPhysicalDeviceCount)));
    mReconstruction.addHandleDependency((const uint64_t*)pPhysicalDevices, (*(pPhysicalDeviceCount)), (uint64_t)(uintptr_t)instance);
    if (!pPhysicalDevices) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkEnumeratePhysicalDevices, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pPhysicalDevices, (*(pPhysicalDeviceCount)), apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pPhysicalDevices, (*(pPhysicalDeviceCount)));
}
void vkGetPhysicalDeviceFeatures(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures* pFeatures)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceFormatProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties* pFormatProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceImageFormatProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkImageFormatProperties* pImageFormatProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties* pProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceQueueFamilyProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties* pQueueFamilyProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceMemoryProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
    // TODO: Implement
}
void vkGetInstanceProcAddr(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    PFN_vkVoidFunction input_result,
    VkInstance instance,
    const char* pName)
{
    // TODO: Implement
}
void vkGetDeviceProcAddr(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    PFN_vkVoidFunction input_result,
    VkDevice device,
    const char* pName)
{
    // TODO: Implement
}
void vkCreateDevice(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkDeviceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDevice* pDevice)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pDevice create
    mReconstruction.addHandles((const uint64_t*)pDevice, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pDevice, 1, (uint64_t)(uintptr_t)physicalDevice);
    if (!pDevice) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateDevice, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pDevice, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pDevice, 1);
}
void vkDestroyDevice(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // device destroy
    mReconstruction.removeHandles((const uint64_t*)(&device), 1);
}
void vkEnumerateInstanceExtensionProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
    // TODO: Implement
}
void vkEnumerateDeviceExtensionProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
    // TODO: Implement
}
void vkEnumerateInstanceLayerProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
    // TODO: Implement
}
void vkEnumerateDeviceLayerProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
    // TODO: Implement
}
void vkGetDeviceQueue(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t queueFamilyIndex,
    uint32_t queueIndex,
    VkQueue* pQueue)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pQueue create
    mReconstruction.addHandles((const uint64_t*)pQueue, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pQueue, 1, (uint64_t)(uintptr_t)device);
    if (!pQueue) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkGetDeviceQueue, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pQueue, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pQueue, 1);
}
void vkQueueSubmit(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue,
    uint32_t submitCount,
    const VkSubmitInfo* pSubmits,
    VkFence fence)
{
    // TODO: Implement
}
void vkQueueWaitIdle(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue)
{
    // TODO: Implement
}
void vkDeviceWaitIdle(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device)
{
    // TODO: Implement
}
void vkAllocateMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkMemoryAllocateInfo* pAllocateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDeviceMemory* pMemory)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pMemory create
    mReconstruction.addHandles((const uint64_t*)pMemory, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pMemory, 1, (uint64_t)(uintptr_t)device);
    if (!pMemory) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkAllocateMemory, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pMemory, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pMemory, 1);
}
void vkFreeMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDeviceMemory memory,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // memory destroy
    mReconstruction.removeHandles((const uint64_t*)(&memory), 1);
}
void vkMapMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize offset,
    VkDeviceSize size,
    VkMemoryMapFlags flags,
    void** ppData)
{
    // TODO: Implement
}
void vkUnmapMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDeviceMemory memory)
{
    // TODO: Implement
}
void vkFlushMappedMemoryRanges(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
    // TODO: Implement
}
void vkInvalidateMappedMemoryRanges(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
    // TODO: Implement
}
void vkGetDeviceMemoryCommitment(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize* pCommittedMemoryInBytes)
{
    // TODO: Implement
}
void vkBindBufferMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkBuffer buffer,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
    // TODO: Implement
}
void vkBindImageMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkImage image,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
    // TODO: Implement
}
void vkGetBufferMemoryRequirements(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkBuffer buffer,
    VkMemoryRequirements* pMemoryRequirements)
{
    // TODO: Implement
}
void vkGetImageMemoryRequirements(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImage image,
    VkMemoryRequirements* pMemoryRequirements)
{
    // TODO: Implement
}
void vkGetImageSparseMemoryRequirements(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImage image,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceSparseImageFormatProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkSampleCountFlagBits samples,
    VkImageUsageFlags usage,
    VkImageTiling tiling,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties* pProperties)
{
    // TODO: Implement
}
void vkQueueBindSparse(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue,
    uint32_t bindInfoCount,
    const VkBindSparseInfo* pBindInfo,
    VkFence fence)
{
    // TODO: Implement
}
void vkCreateFence(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkFenceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pFence create
    mReconstruction.addHandles((const uint64_t*)pFence, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pFence, 1, (uint64_t)(uintptr_t)device);
    if (!pFence) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateFence, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pFence, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pFence, 1);
}
void vkDestroyFence(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkFence fence,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // fence destroy
    mReconstruction.removeHandles((const uint64_t*)(&fence), 1);
}
void vkResetFences(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences)
{
    // TODO: Implement
}
void vkGetFenceStatus(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkFence fence)
{
    // TODO: Implement
}
void vkWaitForFences(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences,
    VkBool32 waitAll,
    uint64_t timeout)
{
    // TODO: Implement
}
void vkCreateSemaphore(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSemaphoreCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSemaphore* pSemaphore)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pSemaphore create
    mReconstruction.addHandles((const uint64_t*)pSemaphore, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pSemaphore, 1, (uint64_t)(uintptr_t)device);
    if (!pSemaphore) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateSemaphore, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pSemaphore, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pSemaphore, 1);
}
void vkDestroySemaphore(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSemaphore semaphore,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // semaphore destroy
    mReconstruction.removeHandles((const uint64_t*)(&semaphore), 1);
}
void vkCreateEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkEventCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkEvent* pEvent)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pEvent create
    mReconstruction.addHandles((const uint64_t*)pEvent, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pEvent, 1, (uint64_t)(uintptr_t)device);
    if (!pEvent) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateEvent, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pEvent, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pEvent, 1);
}
void vkDestroyEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkEvent event,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // event destroy
    mReconstruction.removeHandles((const uint64_t*)(&event), 1);
}
void vkGetEventStatus(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkEvent event)
{
    // TODO: Implement
}
void vkSetEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkEvent event)
{
    // TODO: Implement
}
void vkResetEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkEvent event)
{
    // TODO: Implement
}
void vkCreateQueryPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkQueryPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkQueryPool* pQueryPool)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pQueryPool create
    mReconstruction.addHandles((const uint64_t*)pQueryPool, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pQueryPool, 1, (uint64_t)(uintptr_t)device);
    if (!pQueryPool) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateQueryPool, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pQueryPool, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pQueryPool, 1);
}
void vkDestroyQueryPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkQueryPool queryPool,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // queryPool destroy
    mReconstruction.removeHandles((const uint64_t*)(&queryPool), 1);
}
void vkGetQueryPoolResults(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    size_t dataSize,
    void* pData,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
    // TODO: Implement
}
void vkCreateBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkBufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pBuffer create
    mReconstruction.addHandles((const uint64_t*)pBuffer, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pBuffer, 1, (uint64_t)(uintptr_t)device);
    if (!pBuffer) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateBuffer, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pBuffer, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pBuffer, 1);
}
void vkDestroyBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkBuffer buffer,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // buffer destroy
    mReconstruction.removeHandles((const uint64_t*)(&buffer), 1);
}
void vkCreateBufferView(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkBufferViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBufferView* pView)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pView create
    mReconstruction.addHandles((const uint64_t*)pView, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pView, 1, (uint64_t)(uintptr_t)device);
    if (!pView) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateBufferView, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pView, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pView, 1);
}
void vkDestroyBufferView(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkBufferView bufferView,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // bufferView destroy
    mReconstruction.removeHandles((const uint64_t*)(&bufferView), 1);
}
void vkCreateImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImageCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImage* pImage)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pImage create
    mReconstruction.addHandles((const uint64_t*)pImage, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pImage, 1, (uint64_t)(uintptr_t)device);
    if (!pImage) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateImage, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pImage, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pImage, 1);
}
void vkDestroyImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImage image,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // image destroy
    mReconstruction.removeHandles((const uint64_t*)(&image), 1);
}
void vkGetImageSubresourceLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImage image,
    const VkImageSubresource* pSubresource,
    VkSubresourceLayout* pLayout)
{
    // TODO: Implement
}
void vkCreateImageView(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImageViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImageView* pView)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pView create
    mReconstruction.addHandles((const uint64_t*)pView, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pView, 1, (uint64_t)(uintptr_t)device);
    if (!pView) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateImageView, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pView, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pView, 1);
}
void vkDestroyImageView(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImageView imageView,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // imageView destroy
    mReconstruction.removeHandles((const uint64_t*)(&imageView), 1);
}
void vkCreateShaderModule(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkShaderModuleCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkShaderModule* pShaderModule)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pShaderModule create
    mReconstruction.addHandles((const uint64_t*)pShaderModule, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pShaderModule, 1, (uint64_t)(uintptr_t)device);
    if (!pShaderModule) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateShaderModule, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pShaderModule, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pShaderModule, 1);
}
void vkDestroyShaderModule(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkShaderModule shaderModule,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // shaderModule destroy
    mReconstruction.removeHandles((const uint64_t*)(&shaderModule), 1);
}
void vkCreatePipelineCache(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkPipelineCacheCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineCache* pPipelineCache)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pPipelineCache create
    mReconstruction.addHandles((const uint64_t*)pPipelineCache, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pPipelineCache, 1, (uint64_t)(uintptr_t)device);
    if (!pPipelineCache) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreatePipelineCache, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pPipelineCache, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pPipelineCache, 1);
}
void vkDestroyPipelineCache(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkPipelineCache pipelineCache,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pipelineCache destroy
    mReconstruction.removeHandles((const uint64_t*)(&pipelineCache), 1);
}
void vkGetPipelineCacheData(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipelineCache pipelineCache,
    size_t* pDataSize,
    void* pData)
{
    // TODO: Implement
}
void vkMergePipelineCaches(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipelineCache dstCache,
    uint32_t srcCacheCount,
    const VkPipelineCache* pSrcCaches)
{
    // TODO: Implement
}
void vkCreateGraphicsPipelines(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkGraphicsPipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pPipelines create
    mReconstruction.addHandles((const uint64_t*)pPipelines, ((createInfoCount)));
    mReconstruction.addHandleDependency((const uint64_t*)pPipelines, ((createInfoCount)), (uint64_t)(uintptr_t)device);
    if (!pPipelines) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateGraphicsPipelines, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pPipelines, ((createInfoCount)), apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pPipelines, ((createInfoCount)));
}
void vkCreateComputePipelines(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkComputePipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pPipelines create
    mReconstruction.addHandles((const uint64_t*)pPipelines, ((createInfoCount)));
    mReconstruction.addHandleDependency((const uint64_t*)pPipelines, ((createInfoCount)), (uint64_t)(uintptr_t)device);
    if (!pPipelines) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateComputePipelines, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pPipelines, ((createInfoCount)), apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pPipelines, ((createInfoCount)));
}
void vkDestroyPipeline(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkPipeline pipeline,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pipeline destroy
    mReconstruction.removeHandles((const uint64_t*)(&pipeline), 1);
}
void vkCreatePipelineLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkPipelineLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineLayout* pPipelineLayout)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pPipelineLayout create
    mReconstruction.addHandles((const uint64_t*)pPipelineLayout, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pPipelineLayout, 1, (uint64_t)(uintptr_t)device);
    if (!pPipelineLayout) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreatePipelineLayout, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pPipelineLayout, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pPipelineLayout, 1);
}
void vkDestroyPipelineLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkPipelineLayout pipelineLayout,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pipelineLayout destroy
    mReconstruction.removeHandles((const uint64_t*)(&pipelineLayout), 1);
}
void vkCreateSampler(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSamplerCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSampler* pSampler)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pSampler create
    mReconstruction.addHandles((const uint64_t*)pSampler, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pSampler, 1, (uint64_t)(uintptr_t)device);
    if (!pSampler) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateSampler, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pSampler, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pSampler, 1);
}
void vkDestroySampler(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSampler sampler,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // sampler destroy
    mReconstruction.removeHandles((const uint64_t*)(&sampler), 1);
}
void vkCreateDescriptorSetLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorSetLayout* pSetLayout)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pSetLayout create
    mReconstruction.addHandles((const uint64_t*)pSetLayout, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pSetLayout, 1, (uint64_t)(uintptr_t)device);
    if (!pSetLayout) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateDescriptorSetLayout, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pSetLayout, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pSetLayout, 1);
}
void vkDestroyDescriptorSetLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorSetLayout descriptorSetLayout,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // descriptorSetLayout destroy
    mReconstruction.removeHandles((const uint64_t*)(&descriptorSetLayout), 1);
}
void vkCreateDescriptorPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorPool* pDescriptorPool)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pDescriptorPool create
    mReconstruction.addHandles((const uint64_t*)pDescriptorPool, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pDescriptorPool, 1, (uint64_t)(uintptr_t)device);
    if (!pDescriptorPool) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateDescriptorPool, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pDescriptorPool, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pDescriptorPool, 1);
}
void vkDestroyDescriptorPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // descriptorPool destroy
    mReconstruction.removeHandles((const uint64_t*)(&descriptorPool), 1);
}
void vkResetDescriptorPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    VkDescriptorPoolResetFlags flags)
{
    // TODO: Implement
}
void vkAllocateDescriptorSets(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorSetAllocateInfo* pAllocateInfo,
    VkDescriptorSet* pDescriptorSets)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pDescriptorSets create
    mReconstruction.addHandles((const uint64_t*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
    mReconstruction.addHandleDependency((const uint64_t*)pDescriptorSets, pAllocateInfo->descriptorSetCount, (uint64_t)(uintptr_t)device);
    if (!pDescriptorSets) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkAllocateDescriptorSets, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pDescriptorSets, pAllocateInfo->descriptorSetCount, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pDescriptorSets, pAllocateInfo->descriptorSetCount);
}
void vkFreeDescriptorSets(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pDescriptorSets destroy
    mReconstruction.removeHandles((const uint64_t*)pDescriptorSets, ((descriptorSetCount)));
}
void vkUpdateDescriptorSets(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites,
    uint32_t descriptorCopyCount,
    const VkCopyDescriptorSet* pDescriptorCopies)
{
    // TODO: Implement
}
void vkCreateFramebuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkFramebufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFramebuffer* pFramebuffer)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pFramebuffer create
    mReconstruction.addHandles((const uint64_t*)pFramebuffer, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pFramebuffer, 1, (uint64_t)(uintptr_t)device);
    if (!pFramebuffer) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateFramebuffer, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pFramebuffer, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pFramebuffer, 1);
}
void vkDestroyFramebuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkFramebuffer framebuffer,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // framebuffer destroy
    mReconstruction.removeHandles((const uint64_t*)(&framebuffer), 1);
}
void vkCreateRenderPass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkRenderPassCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pRenderPass create
    mReconstruction.addHandles((const uint64_t*)pRenderPass, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pRenderPass, 1, (uint64_t)(uintptr_t)device);
    if (!pRenderPass) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateRenderPass, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pRenderPass, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pRenderPass, 1);
}
void vkDestroyRenderPass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkRenderPass renderPass,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // renderPass destroy
    mReconstruction.removeHandles((const uint64_t*)(&renderPass), 1);
}
void vkGetRenderAreaGranularity(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkRenderPass renderPass,
    VkExtent2D* pGranularity)
{
    // TODO: Implement
}
void vkCreateCommandPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkCommandPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkCommandPool* pCommandPool)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pCommandPool create
    mReconstruction.addHandles((const uint64_t*)pCommandPool, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pCommandPool, 1, (uint64_t)(uintptr_t)device);
    if (!pCommandPool) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateCommandPool, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pCommandPool, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pCommandPool, 1);
}
void vkDestroyCommandPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkCommandPool commandPool,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // commandPool destroy
    mReconstruction.removeHandles((const uint64_t*)(&commandPool), 1);
}
void vkResetCommandPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolResetFlags flags)
{
    // TODO: Implement
}
void vkAllocateCommandBuffers(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkCommandBufferAllocateInfo* pAllocateInfo,
    VkCommandBuffer* pCommandBuffers)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pCommandBuffers create
    mReconstruction.addHandles((const uint64_t*)pCommandBuffers, pAllocateInfo->commandBufferCount);
    mReconstruction.addHandleDependency((const uint64_t*)pCommandBuffers, pAllocateInfo->commandBufferCount, (uint64_t)(uintptr_t)VkDecoderGlobalState::get()->unboxed_to_boxed_non_dispatchable_VkCommandPool(pAllocateInfo->commandPool));
    if (!pCommandBuffers) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkAllocateCommandBuffers, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pCommandBuffers, pAllocateInfo->commandBufferCount, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pCommandBuffers, pAllocateInfo->commandBufferCount);
}
void vkFreeCommandBuffers(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkCommandPool commandPool,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pCommandBuffers destroy
    mReconstruction.removeHandles((const uint64_t*)pCommandBuffers, ((commandBufferCount)));
}
void vkBeginCommandBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkCommandBuffer commandBuffer,
    const VkCommandBufferBeginInfo* pBeginInfo)
{
    // TODO: Implement
}
void vkEndCommandBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkCommandBuffer commandBuffer)
{
    // TODO: Implement
}
void vkResetCommandBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkCommandBuffer commandBuffer,
    VkCommandBufferResetFlags flags)
{
    // TODO: Implement
}
void vkCmdBindPipeline(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipeline pipeline)
{
    // TODO: Implement
}
void vkCmdSetViewport(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewport* pViewports)
{
    // TODO: Implement
}
void vkCmdSetScissor(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstScissor,
    uint32_t scissorCount,
    const VkRect2D* pScissors)
{
    // TODO: Implement
}
void vkCmdSetLineWidth(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    float lineWidth)
{
    // TODO: Implement
}
void vkCmdSetDepthBias(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    float depthBiasConstantFactor,
    float depthBiasClamp,
    float depthBiasSlopeFactor)
{
    // TODO: Implement
}
void vkCmdSetBlendConstants(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const float blendConstants[4])
{
    // TODO: Implement
}
void vkCmdSetDepthBounds(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    float minDepthBounds,
    float maxDepthBounds)
{
    // TODO: Implement
}
void vkCmdSetStencilCompareMask(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t compareMask)
{
    // TODO: Implement
}
void vkCmdSetStencilWriteMask(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t writeMask)
{
    // TODO: Implement
}
void vkCmdSetStencilReference(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t reference)
{
    // TODO: Implement
}
void vkCmdBindDescriptorSets(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t firstSet,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets,
    uint32_t dynamicOffsetCount,
    const uint32_t* pDynamicOffsets)
{
    // TODO: Implement
}
void vkCmdBindIndexBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkIndexType indexType)
{
    // TODO: Implement
}
void vkCmdBindVertexBuffers(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstBinding,
    uint32_t bindingCount,
    const VkBuffer* pBuffers,
    const VkDeviceSize* pOffsets)
{
    // TODO: Implement
}
void vkCmdDraw(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t vertexCount,
    uint32_t instanceCount,
    uint32_t firstVertex,
    uint32_t firstInstance)
{
    // TODO: Implement
}
void vkCmdDrawIndexed(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t indexCount,
    uint32_t instanceCount,
    uint32_t firstIndex,
    int32_t vertexOffset,
    uint32_t firstInstance)
{
    // TODO: Implement
}
void vkCmdDrawIndirect(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
    // TODO: Implement
}
void vkCmdDrawIndexedIndirect(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
    // TODO: Implement
}
void vkCmdDispatch(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    // TODO: Implement
}
void vkCmdDispatchIndirect(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset)
{
    // TODO: Implement
}
void vkCmdCopyBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferCopy* pRegions)
{
    // TODO: Implement
}
void vkCmdCopyImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageCopy* pRegions)
{
    // TODO: Implement
}
void vkCmdBlitImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageBlit* pRegions,
    VkFilter filter)
{
    // TODO: Implement
}
void vkCmdCopyBufferToImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
    // TODO: Implement
}
void vkCmdCopyImageToBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
    // TODO: Implement
}
void vkCmdUpdateBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize dataSize,
    const void* pData)
{
    // TODO: Implement
}
void vkCmdFillBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize size,
    uint32_t data)
{
    // TODO: Implement
}
void vkCmdClearColorImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearColorValue* pColor,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
    // TODO: Implement
}
void vkCmdClearDepthStencilImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearDepthStencilValue* pDepthStencil,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
    // TODO: Implement
}
void vkCmdClearAttachments(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t attachmentCount,
    const VkClearAttachment* pAttachments,
    uint32_t rectCount,
    const VkClearRect* pRects)
{
    // TODO: Implement
}
void vkCmdResolveImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageResolve* pRegions)
{
    // TODO: Implement
}
void vkCmdSetEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
    // TODO: Implement
}
void vkCmdResetEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
    // TODO: Implement
}
void vkCmdWaitEvents(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    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)
{
    // TODO: Implement
}
void vkCmdPipelineBarrier(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    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)
{
    // TODO: Implement
}
void vkCmdBeginQuery(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query,
    VkQueryControlFlags flags)
{
    // TODO: Implement
}
void vkCmdEndQuery(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query)
{
    // TODO: Implement
}
void vkCmdResetQueryPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount)
{
    // TODO: Implement
}
void vkCmdWriteTimestamp(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkQueryPool queryPool,
    uint32_t query)
{
    // TODO: Implement
}
void vkCmdCopyQueryPoolResults(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
    // TODO: Implement
}
void vkCmdPushConstants(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineLayout layout,
    VkShaderStageFlags stageFlags,
    uint32_t offset,
    uint32_t size,
    const void* pValues)
{
    // TODO: Implement
}
void vkCmdBeginRenderPass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    VkSubpassContents contents)
{
    // TODO: Implement
}
void vkCmdNextSubpass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkSubpassContents contents)
{
    // TODO: Implement
}
void vkCmdEndRenderPass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    // TODO: Implement
}
void vkCmdExecuteCommands(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
    // TODO: Implement
}
#endif
#ifdef VK_VERSION_1_1
void vkEnumerateInstanceVersion(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    uint32_t* pApiVersion)
{
    // TODO: Implement
}
void vkBindBufferMemory2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
    // TODO: Implement
}
void vkBindImageMemory2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
    // TODO: Implement
}
void vkGetDeviceGroupPeerMemoryFeatures(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t heapIndex,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    // TODO: Implement
}
void vkCmdSetDeviceMask(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t deviceMask)
{
    // TODO: Implement
}
void vkCmdDispatchBase(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    // TODO: Implement
}
void vkEnumeratePhysicalDeviceGroups(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    // TODO: Implement
}
void vkGetImageMemoryRequirements2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    // TODO: Implement
}
void vkGetBufferMemoryRequirements2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    // TODO: Implement
}
void vkGetImageSparseMemoryRequirements2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceFeatures2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures2* pFeatures)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceFormatProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceImageFormatProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceQueueFamilyProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceMemoryProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceSparseImageFormatProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
    // TODO: Implement
}
void vkTrimCommandPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
    // TODO: Implement
}
void vkGetDeviceQueue2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkDeviceQueueInfo2* pQueueInfo,
    VkQueue* pQueue)
{
    // TODO: Implement
}
void vkCreateSamplerYcbcrConversion(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pYcbcrConversion create
    mReconstruction.addHandles((const uint64_t*)pYcbcrConversion, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pYcbcrConversion, 1, (uint64_t)(uintptr_t)device);
    if (!pYcbcrConversion) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateSamplerYcbcrConversion, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pYcbcrConversion, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pYcbcrConversion, 1);
}
void vkDestroySamplerYcbcrConversion(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // ycbcrConversion destroy
    mReconstruction.removeHandles((const uint64_t*)(&ycbcrConversion), 1);
}
void vkCreateDescriptorUpdateTemplate(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pDescriptorUpdateTemplate create
    mReconstruction.addHandles((const uint64_t*)pDescriptorUpdateTemplate, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pDescriptorUpdateTemplate, 1, (uint64_t)(uintptr_t)device);
    if (!pDescriptorUpdateTemplate) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateDescriptorUpdateTemplate, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pDescriptorUpdateTemplate, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pDescriptorUpdateTemplate, 1);
}
void vkDestroyDescriptorUpdateTemplate(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // descriptorUpdateTemplate destroy
    mReconstruction.removeHandles((const uint64_t*)(&descriptorUpdateTemplate), 1);
}
void vkUpdateDescriptorSetWithTemplate(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceExternalBufferProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceExternalFenceProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceExternalSemaphoreProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    // TODO: Implement
}
void vkGetDescriptorSetLayoutSupport(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_surface
void vkDestroySurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkSurfaceKHR surface,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // surface destroy
    mReconstruction.removeHandles((const uint64_t*)(&surface), 1);
}
void vkGetPhysicalDeviceSurfaceSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    VkSurfaceKHR surface,
    VkBool32* pSupported)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceSurfaceFormatsKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormatKHR* pSurfaceFormats)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceSurfacePresentModesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pPresentModeCount,
    VkPresentModeKHR* pPresentModes)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_swapchain
void vkCreateSwapchainKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSwapchainCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchain)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pSwapchain create
    mReconstruction.addHandles((const uint64_t*)pSwapchain, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pSwapchain, 1, (uint64_t)(uintptr_t)device);
    if (!pSwapchain) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateSwapchainKHR, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pSwapchain, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pSwapchain, 1);
}
void vkDestroySwapchainKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSwapchainKHR swapchain,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // swapchain destroy
    mReconstruction.removeHandles((const uint64_t*)(&swapchain), 1);
}
void vkGetSwapchainImagesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint32_t* pSwapchainImageCount,
    VkImage* pSwapchainImages)
{
    // TODO: Implement
}
void vkAcquireNextImageKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint64_t timeout,
    VkSemaphore semaphore,
    VkFence fence,
    uint32_t* pImageIndex)
{
    // TODO: Implement
}
void vkQueuePresentKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue,
    const VkPresentInfoKHR* pPresentInfo)
{
    // TODO: Implement
}
void vkGetDeviceGroupPresentCapabilitiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
    // TODO: Implement
}
void vkGetDeviceGroupSurfacePresentModesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSurfaceKHR surface,
    VkDeviceGroupPresentModeFlagsKHR* pModes)
{
    // TODO: Implement
}
void vkGetPhysicalDevicePresentRectanglesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pRectCount,
    VkRect2D* pRects)
{
    // TODO: Implement
}
void vkAcquireNextImage2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkAcquireNextImageInfoKHR* pAcquireInfo,
    uint32_t* pImageIndex)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_display
void vkGetPhysicalDeviceDisplayPropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPropertiesKHR* pProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlanePropertiesKHR* pProperties)
{
    // TODO: Implement
}
void vkGetDisplayPlaneSupportedDisplaysKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t planeIndex,
    uint32_t* pDisplayCount,
    VkDisplayKHR* pDisplays)
{
    // TODO: Implement
}
void vkGetDisplayModePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModePropertiesKHR* pProperties)
{
    // TODO: Implement
}
void vkCreateDisplayModeKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    const VkDisplayModeCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDisplayModeKHR* pMode)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pMode create
    mReconstruction.addHandles((const uint64_t*)pMode, 1);
    if (!pMode) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateDisplayModeKHR, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pMode, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pMode, 1);
}
void vkGetDisplayPlaneCapabilitiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayModeKHR mode,
    uint32_t planeIndex,
    VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
    // TODO: Implement
}
void vkCreateDisplayPlaneSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_display_swapchain
void vkCreateSharedSwapchainsKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainCreateInfoKHR* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchains)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_xlib_surface
void vkCreateXlibSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceXlibPresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    Display* dpy,
    VisualID visualID)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_xcb_surface
void vkCreateXcbSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceXcbPresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    xcb_connection_t* connection,
    xcb_visualid_t visual_id)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_wayland_surface
void vkCreateWaylandSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceWaylandPresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    wl_display* display)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_mir_surface
void vkCreateMirSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkMirSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceMirPresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    MirConnection* connection)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_android_surface
void vkCreateAndroidSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_win32_surface
void vkCreateWin32SurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceWin32PresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_sampler_mirror_clamp_to_edge
#endif
#ifdef VK_KHR_multiview
#endif
#ifdef VK_KHR_get_physical_device_properties2
void vkGetPhysicalDeviceFeatures2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures2* pFeatures)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceFormatProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceImageFormatProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceQueueFamilyProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceMemoryProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_device_group
void vkGetDeviceGroupPeerMemoryFeaturesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t heapIndex,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    // TODO: Implement
}
void vkCmdSetDeviceMaskKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t deviceMask)
{
    // TODO: Implement
}
void vkCmdDispatchBaseKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_shader_draw_parameters
#endif
#ifdef VK_KHR_maintenance1
void vkTrimCommandPoolKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_device_group_creation
void vkEnumeratePhysicalDeviceGroupsKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_external_memory_capabilities
void vkGetPhysicalDeviceExternalBufferPropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_external_memory
#endif
#ifdef VK_KHR_external_memory_win32
void vkGetMemoryWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    // TODO: Implement
}
void vkGetMemoryWin32HandlePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    HANDLE handle,
    VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_external_memory_fd
void vkGetMemoryFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkMemoryGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    // TODO: Implement
}
void vkGetMemoryFdPropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    int fd,
    VkMemoryFdPropertiesKHR* pMemoryFdProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_win32_keyed_mutex
#endif
#ifdef VK_KHR_external_semaphore_capabilities
void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_external_semaphore
#endif
#ifdef VK_KHR_external_semaphore_win32
void vkImportSemaphoreWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
{
    // TODO: Implement
}
void vkGetSemaphoreWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_external_semaphore_fd
void vkImportSemaphoreFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
{
    // TODO: Implement
}
void vkGetSemaphoreFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_push_descriptor
void vkCmdPushDescriptorSetKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t set,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites)
{
    // TODO: Implement
}
void vkCmdPushDescriptorSetWithTemplateKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    VkPipelineLayout layout,
    uint32_t set,
    const void* pData)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_16bit_storage
#endif
#ifdef VK_KHR_incremental_present
#endif
#ifdef VK_KHR_descriptor_update_template
void vkCreateDescriptorUpdateTemplateKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pDescriptorUpdateTemplate create
    mReconstruction.addHandles((const uint64_t*)pDescriptorUpdateTemplate, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pDescriptorUpdateTemplate, 1, (uint64_t)(uintptr_t)device);
    if (!pDescriptorUpdateTemplate) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateDescriptorUpdateTemplateKHR, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pDescriptorUpdateTemplate, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pDescriptorUpdateTemplate, 1);
}
void vkDestroyDescriptorUpdateTemplateKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // descriptorUpdateTemplate destroy
    mReconstruction.removeHandles((const uint64_t*)(&descriptorUpdateTemplate), 1);
}
void vkUpdateDescriptorSetWithTemplateKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_create_renderpass2
void vkCreateRenderPass2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkRenderPassCreateInfo2KHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
    // TODO: Implement
}
void vkCmdBeginRenderPass2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
{
    // TODO: Implement
}
void vkCmdNextSubpass2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
    const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
    // TODO: Implement
}
void vkCmdEndRenderPass2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_shared_presentable_image
void vkGetSwapchainStatusKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_external_fence_capabilities
void vkGetPhysicalDeviceExternalFencePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_external_fence
#endif
#ifdef VK_KHR_external_fence_win32
void vkImportFenceWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
{
    // TODO: Implement
}
void vkGetFenceWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_external_fence_fd
void vkImportFenceFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
{
    // TODO: Implement
}
void vkGetFenceFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkFenceGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_maintenance2
#endif
#ifdef VK_KHR_get_surface_capabilities2
void vkGetPhysicalDeviceSurfaceCapabilities2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceSurfaceFormats2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormat2KHR* pSurfaceFormats)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_variable_pointers
#endif
#ifdef VK_KHR_get_display_properties2
void vkGetPhysicalDeviceDisplayProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayProperties2KHR* pProperties)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlaneProperties2KHR* pProperties)
{
    // TODO: Implement
}
void vkGetDisplayModeProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModeProperties2KHR* pProperties)
{
    // TODO: Implement
}
void vkGetDisplayPlaneCapabilities2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
    VkDisplayPlaneCapabilities2KHR* pCapabilities)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_dedicated_allocation
#endif
#ifdef VK_KHR_storage_buffer_storage_class
#endif
#ifdef VK_KHR_relaxed_block_layout
#endif
#ifdef VK_KHR_get_memory_requirements2
void vkGetImageMemoryRequirements2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    // TODO: Implement
}
void vkGetBufferMemoryRequirements2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    // TODO: Implement
}
void vkGetImageSparseMemoryRequirements2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_image_format_list
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
void vkCreateSamplerYcbcrConversionKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pYcbcrConversion create
    mReconstruction.addHandles((const uint64_t*)pYcbcrConversion, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pYcbcrConversion, 1, (uint64_t)(uintptr_t)device);
    if (!pYcbcrConversion) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateSamplerYcbcrConversionKHR, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pYcbcrConversion, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pYcbcrConversion, 1);
}
void vkDestroySamplerYcbcrConversionKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // ycbcrConversion destroy
    mReconstruction.removeHandles((const uint64_t*)(&ycbcrConversion), 1);
}
#endif
#ifdef VK_KHR_bind_memory2
void vkBindBufferMemory2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
    // TODO: Implement
}
void vkBindImageMemory2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_maintenance3
void vkGetDescriptorSetLayoutSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_draw_indirect_count
void vkCmdDrawIndirectCountKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    // TODO: Implement
}
void vkCmdDrawIndexedIndirectCountKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    // TODO: Implement
}
#endif
#ifdef VK_KHR_8bit_storage
#endif
#ifdef VK_KHR_shader_float16_int8
#endif
#ifdef VK_ANDROID_native_buffer
void vkGetSwapchainGrallocUsageANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkFormat format,
    VkImageUsageFlags imageUsage,
    int* grallocUsage)
{
    // TODO: Implement
}
void vkAcquireImageANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkImage image,
    int nativeFenceFd,
    VkSemaphore semaphore,
    VkFence fence)
{
    // TODO: Implement
}
void vkQueueSignalReleaseImageANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue,
    uint32_t waitSemaphoreCount,
    const VkSemaphore* pWaitSemaphores,
    VkImage image,
    int* pNativeFenceFd)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_debug_report
void vkCreateDebugReportCallbackEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDebugReportCallbackEXT* pCallback)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pCallback create
    mReconstruction.addHandles((const uint64_t*)pCallback, 1);
    if (!pCallback) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateDebugReportCallbackEXT, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pCallback, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pCallback, 1);
}
void vkDestroyDebugReportCallbackEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkDebugReportCallbackEXT callback,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // callback destroy
    mReconstruction.removeHandles((const uint64_t*)(&callback), 1);
}
void vkDebugReportMessageEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkDebugReportFlagsEXT flags,
    VkDebugReportObjectTypeEXT objectType,
    uint64_t object,
    size_t location,
    int32_t messageCode,
    const char* pLayerPrefix,
    const char* pMessage)
{
    // TODO: Implement
}
#endif
#ifdef VK_NV_glsl_shader
#endif
#ifdef VK_EXT_depth_range_unrestricted
#endif
#ifdef VK_IMG_filter_cubic
#endif
#ifdef VK_AMD_rasterization_order
#endif
#ifdef VK_AMD_shader_trinary_minmax
#endif
#ifdef VK_AMD_shader_explicit_vertex_parameter
#endif
#ifdef VK_EXT_debug_marker
void vkDebugMarkerSetObjectTagEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
    // TODO: Implement
}
void vkDebugMarkerSetObjectNameEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
    // TODO: Implement
}
void vkCmdDebugMarkerBeginEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    // TODO: Implement
}
void vkCmdDebugMarkerEndEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    // TODO: Implement
}
void vkCmdDebugMarkerInsertEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    // TODO: Implement
}
#endif
#ifdef VK_AMD_gcn_shader
#endif
#ifdef VK_NV_dedicated_allocation
#endif
#ifdef VK_AMD_draw_indirect_count
void vkCmdDrawIndirectCountAMD(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    // TODO: Implement
}
void vkCmdDrawIndexedIndirectCountAMD(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    // TODO: Implement
}
#endif
#ifdef VK_AMD_negative_viewport_height
#endif
#ifdef VK_AMD_gpu_shader_half_float
#endif
#ifdef VK_AMD_shader_ballot
#endif
#ifdef VK_AMD_texture_gather_bias_lod
#endif
#ifdef VK_AMD_shader_info
void vkGetShaderInfoAMD(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipeline pipeline,
    VkShaderStageFlagBits shaderStage,
    VkShaderInfoTypeAMD infoType,
    size_t* pInfoSize,
    void* pInfo)
{
    // TODO: Implement
}
#endif
#ifdef VK_AMD_shader_image_load_store_lod
#endif
#ifdef VK_IMG_format_pvrtc
#endif
#ifdef VK_NV_external_memory_capabilities
void vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_NV_external_memory
#endif
#ifdef VK_NV_external_memory_win32
void vkGetMemoryWin32HandleNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    VkExternalMemoryHandleTypeFlagsNV handleType,
    HANDLE* pHandle)
{
    // TODO: Implement
}
#endif
#ifdef VK_NV_win32_keyed_mutex
#endif
#ifdef VK_EXT_validation_flags
#endif
#ifdef VK_NN_vi_surface
void vkCreateViSurfaceNN(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkViSurfaceCreateInfoNN* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_shader_subgroup_ballot
#endif
#ifdef VK_EXT_shader_subgroup_vote
#endif
#ifdef VK_EXT_conditional_rendering
void vkCmdBeginConditionalRenderingEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
{
    // TODO: Implement
}
void vkCmdEndConditionalRenderingEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    // TODO: Implement
}
#endif
#ifdef VK_NVX_device_generated_commands
void vkCmdProcessCommandsNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
{
    // TODO: Implement
}
void vkCmdReserveSpaceForCommandsNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
{
    // TODO: Implement
}
void vkCreateIndirectCommandsLayoutNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pIndirectCommandsLayout create
    mReconstruction.addHandles((const uint64_t*)pIndirectCommandsLayout, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pIndirectCommandsLayout, 1, (uint64_t)(uintptr_t)device);
    if (!pIndirectCommandsLayout) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateIndirectCommandsLayoutNVX, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pIndirectCommandsLayout, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pIndirectCommandsLayout, 1);
}
void vkDestroyIndirectCommandsLayoutNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkIndirectCommandsLayoutNVX indirectCommandsLayout,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // indirectCommandsLayout destroy
    mReconstruction.removeHandles((const uint64_t*)(&indirectCommandsLayout), 1);
}
void vkCreateObjectTableNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkObjectTableCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkObjectTableNVX* pObjectTable)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pObjectTable create
    mReconstruction.addHandles((const uint64_t*)pObjectTable, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pObjectTable, 1, (uint64_t)(uintptr_t)device);
    if (!pObjectTable) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateObjectTableNVX, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pObjectTable, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pObjectTable, 1);
}
void vkDestroyObjectTableNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkObjectTableNVX objectTable,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // objectTable destroy
    mReconstruction.removeHandles((const uint64_t*)(&objectTable), 1);
}
void vkRegisterObjectsNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkObjectTableNVX objectTable,
    uint32_t objectCount,
    const VkObjectTableEntryNVX* const* ppObjectTableEntries,
    const uint32_t* pObjectIndices)
{
    // TODO: Implement
}
void vkUnregisterObjectsNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkObjectTableNVX objectTable,
    uint32_t objectCount,
    const VkObjectEntryTypeNVX* pObjectEntryTypes,
    const uint32_t* pObjectIndices)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
    VkDeviceGeneratedCommandsLimitsNVX* pLimits)
{
    // TODO: Implement
}
#endif
#ifdef VK_NV_clip_space_w_scaling
void vkCmdSetViewportWScalingNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewportWScalingNV* pViewportWScalings)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_direct_mode_display
void vkReleaseDisplayEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_acquire_xlib_display
void vkAcquireXlibDisplayEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    Display* dpy,
    VkDisplayKHR display)
{
    // TODO: Implement
}
void vkGetRandROutputDisplayEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    Display* dpy,
    RROutput rrOutput,
    VkDisplayKHR* pDisplay)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_display_surface_counter
void vkGetPhysicalDeviceSurfaceCapabilities2EXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_display_control
void vkDisplayPowerControlEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDisplayKHR display,
    const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
{
    // TODO: Implement
}
void vkRegisterDeviceEventEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDeviceEventInfoEXT* pDeviceEventInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    // TODO: Implement
}
void vkRegisterDisplayEventEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDisplayKHR display,
    const VkDisplayEventInfoEXT* pDisplayEventInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    // TODO: Implement
}
void vkGetSwapchainCounterEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    VkSurfaceCounterFlagBitsEXT counter,
    uint64_t* pCounterValue)
{
    // TODO: Implement
}
#endif
#ifdef VK_GOOGLE_display_timing
void vkGetRefreshCycleDurationGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
    // TODO: Implement
}
void vkGetPastPresentationTimingGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint32_t* pPresentationTimingCount,
    VkPastPresentationTimingGOOGLE* pPresentationTimings)
{
    // TODO: Implement
}
#endif
#ifdef VK_NV_sample_mask_override_coverage
#endif
#ifdef VK_NV_geometry_shader_passthrough
#endif
#ifdef VK_NV_viewport_array2
#endif
#ifdef VK_NVX_multiview_per_view_attributes
#endif
#ifdef VK_NV_viewport_swizzle
#endif
#ifdef VK_EXT_discard_rectangles
void vkCmdSetDiscardRectangleEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstDiscardRectangle,
    uint32_t discardRectangleCount,
    const VkRect2D* pDiscardRectangles)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_conservative_rasterization
#endif
#ifdef VK_EXT_swapchain_colorspace
#endif
#ifdef VK_EXT_hdr_metadata
void vkSetHdrMetadataEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainKHR* pSwapchains,
    const VkHdrMetadataEXT* pMetadata)
{
    // TODO: Implement
}
#endif
#ifdef VK_MVK_ios_surface
void vkCreateIOSSurfaceMVK(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
#endif
#ifdef VK_MVK_macos_surface
void vkCreateMacOSSurfaceMVK(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_external_memory_dma_buf
#endif
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
void vkSetDebugUtilsObjectNameEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
{
    // TODO: Implement
}
void vkSetDebugUtilsObjectTagEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
{
    // TODO: Implement
}
void vkQueueBeginDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    // TODO: Implement
}
void vkQueueEndDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue)
{
    // TODO: Implement
}
void vkQueueInsertDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    // TODO: Implement
}
void vkCmdBeginDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    // TODO: Implement
}
void vkCmdEndDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    // TODO: Implement
}
void vkCmdInsertDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    // TODO: Implement
}
void vkCreateDebugUtilsMessengerEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDebugUtilsMessengerEXT* pMessenger)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pMessenger create
    mReconstruction.addHandles((const uint64_t*)pMessenger, 1);
    if (!pMessenger) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateDebugUtilsMessengerEXT, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pMessenger, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pMessenger, 1);
}
void vkDestroyDebugUtilsMessengerEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkDebugUtilsMessengerEXT messenger,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // messenger destroy
    mReconstruction.removeHandles((const uint64_t*)(&messenger), 1);
}
void vkSubmitDebugUtilsMessageEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
{
    // TODO: Implement
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void vkGetAndroidHardwareBufferPropertiesANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const AHardwareBuffer* buffer,
    VkAndroidHardwareBufferPropertiesANDROID* pProperties)
{
    // TODO: Implement
}
void vkGetMemoryAndroidHardwareBufferANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    AHardwareBuffer** pBuffer)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_sampler_filter_minmax
#endif
#ifdef VK_AMD_gpu_shader_int16
#endif
#ifdef VK_AMD_mixed_attachment_samples
#endif
#ifdef VK_AMD_shader_fragment_mask
#endif
#ifdef VK_EXT_shader_stencil_export
#endif
#ifdef VK_EXT_sample_locations
void vkCmdSetSampleLocationsEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
    // TODO: Implement
}
void vkGetPhysicalDeviceMultisamplePropertiesEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkSampleCountFlagBits samples,
    VkMultisamplePropertiesEXT* pMultisampleProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_blend_operation_advanced
#endif
#ifdef VK_NV_fragment_coverage_to_color
#endif
#ifdef VK_NV_framebuffer_mixed_samples
#endif
#ifdef VK_NV_fill_rectangle
#endif
#ifdef VK_EXT_post_depth_coverage
#endif
#ifdef VK_EXT_validation_cache
void vkCreateValidationCacheEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkValidationCacheCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkValidationCacheEXT* pValidationCache)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pValidationCache create
    mReconstruction.addHandles((const uint64_t*)pValidationCache, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pValidationCache, 1, (uint64_t)(uintptr_t)device);
    if (!pValidationCache) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateValidationCacheEXT, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pValidationCache, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pValidationCache, 1);
}
void vkDestroyValidationCacheEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkValidationCacheEXT validationCache,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // validationCache destroy
    mReconstruction.removeHandles((const uint64_t*)(&validationCache), 1);
}
void vkMergeValidationCachesEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkValidationCacheEXT dstCache,
    uint32_t srcCacheCount,
    const VkValidationCacheEXT* pSrcCaches)
{
    // TODO: Implement
}
void vkGetValidationCacheDataEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkValidationCacheEXT validationCache,
    size_t* pDataSize,
    void* pData)
{
    // TODO: Implement
}
#endif
#ifdef VK_EXT_descriptor_indexing
#endif
#ifdef VK_EXT_shader_viewport_index_layer
#endif
#ifdef VK_EXT_global_priority
#endif
#ifdef VK_EXT_external_memory_host
void vkGetMemoryHostPointerPropertiesEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    const void* pHostPointer,
    VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
{
    // TODO: Implement
}
#endif
#ifdef VK_AMD_buffer_marker
void vkCmdWriteBufferMarkerAMD(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    uint32_t marker)
{
    // TODO: Implement
}
#endif
#ifdef VK_AMD_shader_core_properties
#endif
#ifdef VK_EXT_vertex_attribute_divisor
#endif
#ifdef VK_NV_shader_subgroup_partitioned
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void vkCmdSetCheckpointNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const void* pCheckpointMarker)
{
    // TODO: Implement
}
void vkGetQueueCheckpointDataNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    uint32_t* pCheckpointDataCount,
    VkCheckpointDataNV* pCheckpointData)
{
    // TODO: Implement
}
#endif
#ifdef VK_GOOGLE_address_space
void vkMapMemoryIntoAddressSpaceGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    uint64_t* pAddress)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // memory modify
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkMapMemoryIntoAddressSpaceGOOGLE, snapshotTraceBegin, snapshotTraceBytes);
    for (uint32_t i = 0; i < 1; ++i)
    {
        VkDeviceMemory boxed = VkDecoderGlobalState::get()->unboxed_to_boxed_non_dispatchable_VkDeviceMemory((&memory)[i]);
        mReconstruction.forEachHandleAddModifyApi((const uint64_t*)(&boxed), 1, apiHandle);
    }
}
#endif
#ifdef VK_GOOGLE_color_buffer
void vkRegisterImageColorBufferGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkImage image,
    uint32_t colorBuffer)
{
    // TODO: Implement
}
void vkRegisterBufferColorBufferGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkBuffer buffer,
    uint32_t colorBuffer)
{
    // TODO: Implement
}
#endif
#ifdef VK_GOOGLE_sized_descriptor_update_template
void vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    uint32_t imageInfoCount,
    uint32_t bufferInfoCount,
    uint32_t bufferViewCount,
    const uint32_t* pImageInfoEntryIndices,
    const uint32_t* pBufferInfoEntryIndices,
    const uint32_t* pBufferViewEntryIndices,
    const VkDescriptorImageInfo* pImageInfos,
    const VkDescriptorBufferInfo* pBufferInfos,
    const VkBufferView* pBufferViews)
{
    // TODO: Implement
}
#endif
#ifdef VK_GOOGLE_async_command_buffers
void vkBeginCommandBufferAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkCommandBufferBeginInfo* pBeginInfo)
{
    // TODO: Implement
}
void vkEndCommandBufferAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    // TODO: Implement
}
void vkResetCommandBufferAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkCommandBufferResetFlags flags)
{
    // TODO: Implement
}
void vkCommandBufferHostSyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t needHostSync,
    uint32_t sequenceNumber)
{
    // TODO: Implement
}
#endif
#ifdef VK_GOOGLE_create_resources_with_requirements
void vkCreateImageWithRequirementsGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImageCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImage* pImage,
    VkMemoryRequirements* pMemoryRequirements)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pImage create
    mReconstruction.addHandles((const uint64_t*)pImage, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pImage, 1, (uint64_t)(uintptr_t)device);
    if (!pImage) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateImageWithRequirementsGOOGLE, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pImage, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pImage, 1);
}
void vkCreateBufferWithRequirementsGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkBufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer,
    VkMemoryRequirements* pMemoryRequirements)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // pBuffer create
    mReconstruction.addHandles((const uint64_t*)pBuffer, 1);
    mReconstruction.addHandleDependency((const uint64_t*)pBuffer, 1, (uint64_t)(uintptr_t)device);
    if (!pBuffer) return;
    auto apiHandle = mReconstruction.createApiInfo();
    auto apiInfo = mReconstruction.getApiInfo(apiHandle);
    mReconstruction.setApiTrace(apiInfo, OP_vkCreateBufferWithRequirementsGOOGLE, snapshotTraceBegin, snapshotTraceBytes);
    mReconstruction.forEachHandleAddApi((const uint64_t*)pBuffer, 1, apiHandle);
    mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pBuffer, 1);
}
#endif
#ifdef VK_GOOGLE_address_space_info
void vkGetMemoryHostAddressInfoGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    uint64_t* pAddress,
    uint64_t* pSize,
    uint64_t* pHostmemId)
{
    // TODO: Implement
}
#endif
#ifdef VK_GOOGLE_free_memory_sync
void vkFreeMemorySyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    const VkAllocationCallbacks* pAllocator)
{
    // TODO: Implement
    android::base::AutoLock lock(mLock);
    // memory destroy
    mReconstruction.removeHandles((const uint64_t*)(&memory), 1);
}
#endif
#ifdef VK_GOOGLE_async_queue_submit
void vkQueueHostSyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    uint32_t needHostSync,
    uint32_t sequenceNumber)
{
    // TODO: Implement
}
void vkQueueSubmitAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    uint32_t submitCount,
    const VkSubmitInfo* pSubmits,
    VkFence fence)
{
    // TODO: Implement
}
void vkQueueWaitIdleAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue)
{
    // TODO: Implement
}
void vkQueueBindSparseAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    uint32_t bindInfoCount,
    const VkBindSparseInfo* pBindInfo,
    VkFence fence)
{
    // TODO: Implement
}
#endif
#ifdef VK_GOOGLE_linear_image_layout
void vkGetLinearImageLayoutGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkFormat format,
    VkDeviceSize* pOffset,
    VkDeviceSize* pRowPitchAlignment)
{
    // TODO: Implement
}
#endif

private:
    android::base::Lock mLock;
    VkReconstruction mReconstruction;
};

VkDecoderSnapshot::VkDecoderSnapshot() :
    mImpl(new VkDecoderSnapshot::Impl()) { }

void VkDecoderSnapshot::save(android::base::Stream* stream) {
    mImpl->save(stream);
}

void VkDecoderSnapshot::load(android::base::Stream* stream) {
    mImpl->load(stream);
}

VkDecoderSnapshot::~VkDecoderSnapshot() = default;
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateInstance(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    const VkInstanceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkInstance* pInstance)
{
    mImpl->vkCreateInstance(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, pCreateInfo, pAllocator, pInstance);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyInstance(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyInstance(snapshotTraceBegin, snapshotTraceBytes, pool, instance, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkEnumeratePhysicalDevices(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    uint32_t* pPhysicalDeviceCount,
    VkPhysicalDevice* pPhysicalDevices)
{
    mImpl->vkEnumeratePhysicalDevices(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pPhysicalDeviceCount, pPhysicalDevices);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetPhysicalDeviceFeatures(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures* pFeatures)
{
    mImpl->vkGetPhysicalDeviceFeatures(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pFeatures);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetPhysicalDeviceFormatProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties* pFormatProperties)
{
    mImpl->vkGetPhysicalDeviceFormatProperties(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, format, pFormatProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetPhysicalDeviceImageFormatProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkImageFormatProperties* pImageFormatProperties)
{
    mImpl->vkGetPhysicalDeviceImageFormatProperties(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetPhysicalDeviceProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties* pProperties)
{
    mImpl->vkGetPhysicalDeviceProperties(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetPhysicalDeviceQueueFamilyProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties* pQueueFamilyProperties)
{
    mImpl->vkGetPhysicalDeviceQueueFamilyProperties(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetPhysicalDeviceMemoryProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
    mImpl->vkGetPhysicalDeviceMemoryProperties(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pMemoryProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetInstanceProcAddr(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    PFN_vkVoidFunction input_result,
    VkInstance instance,
    const char* pName)
{
    mImpl->vkGetInstanceProcAddr(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pName);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetDeviceProcAddr(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    PFN_vkVoidFunction input_result,
    VkDevice device,
    const char* pName)
{
    mImpl->vkGetDeviceProcAddr(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pName);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateDevice(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkDeviceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDevice* pDevice)
{
    mImpl->vkCreateDevice(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pCreateInfo, pAllocator, pDevice);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyDevice(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyDevice(snapshotTraceBegin, snapshotTraceBytes, pool, device, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkEnumerateInstanceExtensionProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
    mImpl->vkEnumerateInstanceExtensionProperties(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, pLayerName, pPropertyCount, pProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkEnumerateDeviceExtensionProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const char* pLayerName,
    uint32_t* pPropertyCount,
    VkExtensionProperties* pProperties)
{
    mImpl->vkEnumerateDeviceExtensionProperties(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pLayerName, pPropertyCount, pProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkEnumerateInstanceLayerProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
    mImpl->vkEnumerateInstanceLayerProperties(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, pPropertyCount, pProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkEnumerateDeviceLayerProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkLayerProperties* pProperties)
{
    mImpl->vkEnumerateDeviceLayerProperties(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pPropertyCount, pProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetDeviceQueue(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t queueFamilyIndex,
    uint32_t queueIndex,
    VkQueue* pQueue)
{
    mImpl->vkGetDeviceQueue(snapshotTraceBegin, snapshotTraceBytes, pool, device, queueFamilyIndex, queueIndex, pQueue);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkQueueSubmit(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue,
    uint32_t submitCount,
    const VkSubmitInfo* pSubmits,
    VkFence fence)
{
    mImpl->vkQueueSubmit(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, queue, submitCount, pSubmits, fence);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkQueueWaitIdle(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue)
{
    mImpl->vkQueueWaitIdle(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, queue);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDeviceWaitIdle(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device)
{
    mImpl->vkDeviceWaitIdle(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkAllocateMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkMemoryAllocateInfo* pAllocateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDeviceMemory* pMemory)
{
    mImpl->vkAllocateMemory(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pAllocateInfo, pAllocator, pMemory);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkFreeMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDeviceMemory memory,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkFreeMemory(snapshotTraceBegin, snapshotTraceBytes, pool, device, memory, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkMapMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize offset,
    VkDeviceSize size,
    VkMemoryMapFlags flags,
    void** ppData)
{
    mImpl->vkMapMemory(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, memory, offset, size, flags, ppData);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkUnmapMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDeviceMemory memory)
{
    mImpl->vkUnmapMemory(snapshotTraceBegin, snapshotTraceBytes, pool, device, memory);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkFlushMappedMemoryRanges(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
    mImpl->vkFlushMappedMemoryRanges(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, memoryRangeCount, pMemoryRanges);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkInvalidateMappedMemoryRanges(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t memoryRangeCount,
    const VkMappedMemoryRange* pMemoryRanges)
{
    mImpl->vkInvalidateMappedMemoryRanges(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, memoryRangeCount, pMemoryRanges);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetDeviceMemoryCommitment(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDeviceMemory memory,
    VkDeviceSize* pCommittedMemoryInBytes)
{
    mImpl->vkGetDeviceMemoryCommitment(snapshotTraceBegin, snapshotTraceBytes, pool, device, memory, pCommittedMemoryInBytes);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkBindBufferMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkBuffer buffer,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
    mImpl->vkBindBufferMemory(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, buffer, memory, memoryOffset);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkBindImageMemory(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkImage image,
    VkDeviceMemory memory,
    VkDeviceSize memoryOffset)
{
    mImpl->vkBindImageMemory(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, image, memory, memoryOffset);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetBufferMemoryRequirements(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkBuffer buffer,
    VkMemoryRequirements* pMemoryRequirements)
{
    mImpl->vkGetBufferMemoryRequirements(snapshotTraceBegin, snapshotTraceBytes, pool, device, buffer, pMemoryRequirements);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetImageMemoryRequirements(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImage image,
    VkMemoryRequirements* pMemoryRequirements)
{
    mImpl->vkGetImageMemoryRequirements(snapshotTraceBegin, snapshotTraceBytes, pool, device, image, pMemoryRequirements);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetImageSparseMemoryRequirements(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImage image,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
    mImpl->vkGetImageSparseMemoryRequirements(snapshotTraceBegin, snapshotTraceBytes, pool, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetPhysicalDeviceSparseImageFormatProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkSampleCountFlagBits samples,
    VkImageUsageFlags usage,
    VkImageTiling tiling,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties* pProperties)
{
    mImpl->vkGetPhysicalDeviceSparseImageFormatProperties(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkQueueBindSparse(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue,
    uint32_t bindInfoCount,
    const VkBindSparseInfo* pBindInfo,
    VkFence fence)
{
    mImpl->vkQueueBindSparse(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, queue, bindInfoCount, pBindInfo, fence);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateFence(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkFenceCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    mImpl->vkCreateFence(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pFence);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyFence(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkFence fence,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyFence(snapshotTraceBegin, snapshotTraceBytes, pool, device, fence, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkResetFences(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences)
{
    mImpl->vkResetFences(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, fenceCount, pFences);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetFenceStatus(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkFence fence)
{
    mImpl->vkGetFenceStatus(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, fence);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkWaitForFences(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t fenceCount,
    const VkFence* pFences,
    VkBool32 waitAll,
    uint64_t timeout)
{
    mImpl->vkWaitForFences(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, fenceCount, pFences, waitAll, timeout);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateSemaphore(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSemaphoreCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSemaphore* pSemaphore)
{
    mImpl->vkCreateSemaphore(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pSemaphore);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroySemaphore(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSemaphore semaphore,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroySemaphore(snapshotTraceBegin, snapshotTraceBytes, pool, device, semaphore, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkEventCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkEvent* pEvent)
{
    mImpl->vkCreateEvent(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pEvent);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkEvent event,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyEvent(snapshotTraceBegin, snapshotTraceBytes, pool, device, event, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetEventStatus(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkEvent event)
{
    mImpl->vkGetEventStatus(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, event);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkSetEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkEvent event)
{
    mImpl->vkSetEvent(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, event);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkResetEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkEvent event)
{
    mImpl->vkResetEvent(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, event);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateQueryPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkQueryPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkQueryPool* pQueryPool)
{
    mImpl->vkCreateQueryPool(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pQueryPool);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyQueryPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkQueryPool queryPool,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyQueryPool(snapshotTraceBegin, snapshotTraceBytes, pool, device, queryPool, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetQueryPoolResults(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    size_t dataSize,
    void* pData,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
    mImpl->vkGetQueryPoolResults(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkBufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer)
{
    mImpl->vkCreateBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pBuffer);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkBuffer buffer,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, device, buffer, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateBufferView(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkBufferViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBufferView* pView)
{
    mImpl->vkCreateBufferView(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pView);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyBufferView(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkBufferView bufferView,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyBufferView(snapshotTraceBegin, snapshotTraceBytes, pool, device, bufferView, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImageCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImage* pImage)
{
    mImpl->vkCreateImage(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pImage);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImage image,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyImage(snapshotTraceBegin, snapshotTraceBytes, pool, device, image, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetImageSubresourceLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImage image,
    const VkImageSubresource* pSubresource,
    VkSubresourceLayout* pLayout)
{
    mImpl->vkGetImageSubresourceLayout(snapshotTraceBegin, snapshotTraceBytes, pool, device, image, pSubresource, pLayout);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateImageView(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImageViewCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImageView* pView)
{
    mImpl->vkCreateImageView(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pView);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyImageView(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkImageView imageView,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyImageView(snapshotTraceBegin, snapshotTraceBytes, pool, device, imageView, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateShaderModule(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkShaderModuleCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkShaderModule* pShaderModule)
{
    mImpl->vkCreateShaderModule(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pShaderModule);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyShaderModule(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkShaderModule shaderModule,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyShaderModule(snapshotTraceBegin, snapshotTraceBytes, pool, device, shaderModule, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreatePipelineCache(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkPipelineCacheCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineCache* pPipelineCache)
{
    mImpl->vkCreatePipelineCache(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pPipelineCache);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyPipelineCache(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkPipelineCache pipelineCache,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyPipelineCache(snapshotTraceBegin, snapshotTraceBytes, pool, device, pipelineCache, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetPipelineCacheData(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipelineCache pipelineCache,
    size_t* pDataSize,
    void* pData)
{
    mImpl->vkGetPipelineCacheData(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pipelineCache, pDataSize, pData);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkMergePipelineCaches(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipelineCache dstCache,
    uint32_t srcCacheCount,
    const VkPipelineCache* pSrcCaches)
{
    mImpl->vkMergePipelineCaches(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, dstCache, srcCacheCount, pSrcCaches);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateGraphicsPipelines(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkGraphicsPipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
    mImpl->vkCreateGraphicsPipelines(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateComputePipelines(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipelineCache pipelineCache,
    uint32_t createInfoCount,
    const VkComputePipelineCreateInfo* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkPipeline* pPipelines)
{
    mImpl->vkCreateComputePipelines(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyPipeline(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkPipeline pipeline,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyPipeline(snapshotTraceBegin, snapshotTraceBytes, pool, device, pipeline, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreatePipelineLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkPipelineLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkPipelineLayout* pPipelineLayout)
{
    mImpl->vkCreatePipelineLayout(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pPipelineLayout);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyPipelineLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkPipelineLayout pipelineLayout,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyPipelineLayout(snapshotTraceBegin, snapshotTraceBytes, pool, device, pipelineLayout, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateSampler(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSamplerCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSampler* pSampler)
{
    mImpl->vkCreateSampler(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pSampler);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroySampler(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSampler sampler,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroySampler(snapshotTraceBegin, snapshotTraceBytes, pool, device, sampler, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateDescriptorSetLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorSetLayout* pSetLayout)
{
    mImpl->vkCreateDescriptorSetLayout(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pSetLayout);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyDescriptorSetLayout(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorSetLayout descriptorSetLayout,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyDescriptorSetLayout(snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorSetLayout, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateDescriptorPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorPool* pDescriptorPool)
{
    mImpl->vkCreateDescriptorPool(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pDescriptorPool);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyDescriptorPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyDescriptorPool(snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorPool, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkResetDescriptorPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    VkDescriptorPoolResetFlags flags)
{
    mImpl->vkResetDescriptorPool(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, descriptorPool, flags);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkAllocateDescriptorSets(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorSetAllocateInfo* pAllocateInfo,
    VkDescriptorSet* pDescriptorSets)
{
    mImpl->vkAllocateDescriptorSets(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pAllocateInfo, pDescriptorSets);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkFreeDescriptorSets(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDescriptorPool descriptorPool,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets)
{
    mImpl->vkFreeDescriptorSets(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, descriptorPool, descriptorSetCount, pDescriptorSets);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkUpdateDescriptorSets(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites,
    uint32_t descriptorCopyCount,
    const VkCopyDescriptorSet* pDescriptorCopies)
{
    mImpl->vkUpdateDescriptorSets(snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateFramebuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkFramebufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFramebuffer* pFramebuffer)
{
    mImpl->vkCreateFramebuffer(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pFramebuffer);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyFramebuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkFramebuffer framebuffer,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyFramebuffer(snapshotTraceBegin, snapshotTraceBytes, pool, device, framebuffer, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateRenderPass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkRenderPassCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
    mImpl->vkCreateRenderPass(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pRenderPass);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyRenderPass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkRenderPass renderPass,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyRenderPass(snapshotTraceBegin, snapshotTraceBytes, pool, device, renderPass, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkGetRenderAreaGranularity(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkRenderPass renderPass,
    VkExtent2D* pGranularity)
{
    mImpl->vkGetRenderAreaGranularity(snapshotTraceBegin, snapshotTraceBytes, pool, device, renderPass, pGranularity);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCreateCommandPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkCommandPoolCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkCommandPool* pCommandPool)
{
    mImpl->vkCreateCommandPool(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pCommandPool);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkDestroyCommandPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkCommandPool commandPool,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyCommandPool(snapshotTraceBegin, snapshotTraceBytes, pool, device, commandPool, pAllocator);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkResetCommandPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolResetFlags flags)
{
    mImpl->vkResetCommandPool(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, commandPool, flags);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkAllocateCommandBuffers(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkCommandBufferAllocateInfo* pAllocateInfo,
    VkCommandBuffer* pCommandBuffers)
{
    mImpl->vkAllocateCommandBuffers(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pAllocateInfo, pCommandBuffers);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkFreeCommandBuffers(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkCommandPool commandPool,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
    mImpl->vkFreeCommandBuffers(snapshotTraceBegin, snapshotTraceBytes, pool, device, commandPool, commandBufferCount, pCommandBuffers);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkBeginCommandBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkCommandBuffer commandBuffer,
    const VkCommandBufferBeginInfo* pBeginInfo)
{
    mImpl->vkBeginCommandBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, commandBuffer, pBeginInfo);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkEndCommandBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkCommandBuffer commandBuffer)
{
    mImpl->vkEndCommandBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, commandBuffer);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkResetCommandBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkCommandBuffer commandBuffer,
    VkCommandBufferResetFlags flags)
{
    mImpl->vkResetCommandBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, commandBuffer, flags);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdBindPipeline(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipeline pipeline)
{
    mImpl->vkCmdBindPipeline(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pipelineBindPoint, pipeline);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetViewport(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewport* pViewports)
{
    mImpl->vkCmdSetViewport(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, firstViewport, viewportCount, pViewports);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetScissor(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstScissor,
    uint32_t scissorCount,
    const VkRect2D* pScissors)
{
    mImpl->vkCmdSetScissor(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, firstScissor, scissorCount, pScissors);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetLineWidth(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    float lineWidth)
{
    mImpl->vkCmdSetLineWidth(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, lineWidth);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetDepthBias(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    float depthBiasConstantFactor,
    float depthBiasClamp,
    float depthBiasSlopeFactor)
{
    mImpl->vkCmdSetDepthBias(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetBlendConstants(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const float blendConstants[4])
{
    mImpl->vkCmdSetBlendConstants(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, blendConstants);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetDepthBounds(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    float minDepthBounds,
    float maxDepthBounds)
{
    mImpl->vkCmdSetDepthBounds(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, minDepthBounds, maxDepthBounds);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetStencilCompareMask(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t compareMask)
{
    mImpl->vkCmdSetStencilCompareMask(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, faceMask, compareMask);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetStencilWriteMask(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t writeMask)
{
    mImpl->vkCmdSetStencilWriteMask(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, faceMask, writeMask);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetStencilReference(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkStencilFaceFlags faceMask,
    uint32_t reference)
{
    mImpl->vkCmdSetStencilReference(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, faceMask, reference);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdBindDescriptorSets(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t firstSet,
    uint32_t descriptorSetCount,
    const VkDescriptorSet* pDescriptorSets,
    uint32_t dynamicOffsetCount,
    const uint32_t* pDynamicOffsets)
{
    mImpl->vkCmdBindDescriptorSets(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdBindIndexBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkIndexType indexType)
{
    mImpl->vkCmdBindIndexBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, buffer, offset, indexType);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdBindVertexBuffers(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstBinding,
    uint32_t bindingCount,
    const VkBuffer* pBuffers,
    const VkDeviceSize* pOffsets)
{
    mImpl->vkCmdBindVertexBuffers(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdDraw(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t vertexCount,
    uint32_t instanceCount,
    uint32_t firstVertex,
    uint32_t firstInstance)
{
    mImpl->vkCmdDraw(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdDrawIndexed(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t indexCount,
    uint32_t instanceCount,
    uint32_t firstIndex,
    int32_t vertexOffset,
    uint32_t firstInstance)
{
    mImpl->vkCmdDrawIndexed(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdDrawIndirect(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
    mImpl->vkCmdDrawIndirect(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, buffer, offset, drawCount, stride);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdDrawIndexedIndirect(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    uint32_t drawCount,
    uint32_t stride)
{
    mImpl->vkCmdDrawIndexedIndirect(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, buffer, offset, drawCount, stride);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdDispatch(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    mImpl->vkCmdDispatch(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, groupCountX, groupCountY, groupCountZ);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdDispatchIndirect(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset)
{
    mImpl->vkCmdDispatchIndirect(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, buffer, offset);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdCopyBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferCopy* pRegions)
{
    mImpl->vkCmdCopyBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdCopyImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageCopy* pRegions)
{
    mImpl->vkCmdCopyImage(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdBlitImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageBlit* pRegions,
    VkFilter filter)
{
    mImpl->vkCmdBlitImage(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdCopyBufferToImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer srcBuffer,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
    mImpl->vkCmdCopyBufferToImage(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdCopyImageToBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkBuffer dstBuffer,
    uint32_t regionCount,
    const VkBufferImageCopy* pRegions)
{
    mImpl->vkCmdCopyImageToBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdUpdateBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize dataSize,
    const void* pData)
{
    mImpl->vkCmdUpdateBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdFillBuffer(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize size,
    uint32_t data)
{
    mImpl->vkCmdFillBuffer(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, dstBuffer, dstOffset, size, data);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdClearColorImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearColorValue* pColor,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
    mImpl->vkCmdClearColorImage(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdClearDepthStencilImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage image,
    VkImageLayout imageLayout,
    const VkClearDepthStencilValue* pDepthStencil,
    uint32_t rangeCount,
    const VkImageSubresourceRange* pRanges)
{
    mImpl->vkCmdClearDepthStencilImage(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdClearAttachments(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t attachmentCount,
    const VkClearAttachment* pAttachments,
    uint32_t rectCount,
    const VkClearRect* pRects)
{
    mImpl->vkCmdClearAttachments(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdResolveImage(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkImage srcImage,
    VkImageLayout srcImageLayout,
    VkImage dstImage,
    VkImageLayout dstImageLayout,
    uint32_t regionCount,
    const VkImageResolve* pRegions)
{
    mImpl->vkCmdResolveImage(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdSetEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
    mImpl->vkCmdSetEvent(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, event, stageMask);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdResetEvent(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkEvent event,
    VkPipelineStageFlags stageMask)
{
    mImpl->vkCmdResetEvent(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, event, stageMask);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdWaitEvents(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    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)
{
    mImpl->vkCmdWaitEvents(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdPipelineBarrier(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    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)
{
    mImpl->vkCmdPipelineBarrier(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdBeginQuery(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query,
    VkQueryControlFlags flags)
{
    mImpl->vkCmdBeginQuery(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, queryPool, query, flags);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdEndQuery(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t query)
{
    mImpl->vkCmdEndQuery(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, queryPool, query);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdResetQueryPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount)
{
    mImpl->vkCmdResetQueryPool(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, queryPool, firstQuery, queryCount);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdWriteTimestamp(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkQueryPool queryPool,
    uint32_t query)
{
    mImpl->vkCmdWriteTimestamp(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pipelineStage, queryPool, query);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdCopyQueryPoolResults(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkQueryPool queryPool,
    uint32_t firstQuery,
    uint32_t queryCount,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    VkDeviceSize stride,
    VkQueryResultFlags flags)
{
    mImpl->vkCmdCopyQueryPoolResults(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdPushConstants(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineLayout layout,
    VkShaderStageFlags stageFlags,
    uint32_t offset,
    uint32_t size,
    const void* pValues)
{
    mImpl->vkCmdPushConstants(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, layout, stageFlags, offset, size, pValues);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdBeginRenderPass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    VkSubpassContents contents)
{
    mImpl->vkCmdBeginRenderPass(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pRenderPassBegin, contents);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdNextSubpass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkSubpassContents contents)
{
    mImpl->vkCmdNextSubpass(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, contents);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdEndRenderPass(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    mImpl->vkCmdEndRenderPass(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer);
}
#endif
#ifdef VK_VERSION_1_0
void VkDecoderSnapshot::vkCmdExecuteCommands(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t commandBufferCount,
    const VkCommandBuffer* pCommandBuffers)
{
    mImpl->vkCmdExecuteCommands(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, commandBufferCount, pCommandBuffers);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkEnumerateInstanceVersion(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    uint32_t* pApiVersion)
{
    mImpl->vkEnumerateInstanceVersion(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, pApiVersion);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkBindBufferMemory2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
    mImpl->vkBindBufferMemory2(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, bindInfoCount, pBindInfos);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkBindImageMemory2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
    mImpl->vkBindImageMemory2(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, bindInfoCount, pBindInfos);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetDeviceGroupPeerMemoryFeatures(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t heapIndex,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    mImpl->vkGetDeviceGroupPeerMemoryFeatures(snapshotTraceBegin, snapshotTraceBytes, pool, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkCmdSetDeviceMask(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t deviceMask)
{
    mImpl->vkCmdSetDeviceMask(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, deviceMask);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkCmdDispatchBase(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    mImpl->vkCmdDispatchBase(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkEnumeratePhysicalDeviceGroups(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    mImpl->vkEnumeratePhysicalDeviceGroups(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetImageMemoryRequirements2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    mImpl->vkGetImageMemoryRequirements2(snapshotTraceBegin, snapshotTraceBytes, pool, device, pInfo, pMemoryRequirements);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetBufferMemoryRequirements2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    mImpl->vkGetBufferMemoryRequirements2(snapshotTraceBegin, snapshotTraceBytes, pool, device, pInfo, pMemoryRequirements);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetImageSparseMemoryRequirements2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    mImpl->vkGetImageSparseMemoryRequirements2(snapshotTraceBegin, snapshotTraceBytes, pool, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceFeatures2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures2* pFeatures)
{
    mImpl->vkGetPhysicalDeviceFeatures2(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pFeatures);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
    mImpl->vkGetPhysicalDeviceProperties2(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceFormatProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
    mImpl->vkGetPhysicalDeviceFormatProperties2(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, format, pFormatProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceImageFormatProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
    mImpl->vkGetPhysicalDeviceImageFormatProperties2(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pImageFormatInfo, pImageFormatProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceQueueFamilyProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    mImpl->vkGetPhysicalDeviceQueueFamilyProperties2(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceMemoryProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    mImpl->vkGetPhysicalDeviceMemoryProperties2(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pMemoryProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceSparseImageFormatProperties2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
    mImpl->vkGetPhysicalDeviceSparseImageFormatProperties2(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkTrimCommandPool(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
    mImpl->vkTrimCommandPool(snapshotTraceBegin, snapshotTraceBytes, pool, device, commandPool, flags);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetDeviceQueue2(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkDeviceQueueInfo2* pQueueInfo,
    VkQueue* pQueue)
{
    mImpl->vkGetDeviceQueue2(snapshotTraceBegin, snapshotTraceBytes, pool, device, pQueueInfo, pQueue);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkCreateSamplerYcbcrConversion(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
    mImpl->vkCreateSamplerYcbcrConversion(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pYcbcrConversion);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkDestroySamplerYcbcrConversion(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroySamplerYcbcrConversion(snapshotTraceBegin, snapshotTraceBytes, pool, device, ycbcrConversion, pAllocator);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkCreateDescriptorUpdateTemplate(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    mImpl->vkCreateDescriptorUpdateTemplate(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkDestroyDescriptorUpdateTemplate(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyDescriptorUpdateTemplate(snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorUpdateTemplate, pAllocator);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkUpdateDescriptorSetWithTemplate(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
    mImpl->vkUpdateDescriptorSetWithTemplate(snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorSet, descriptorUpdateTemplate, pData);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceExternalBufferProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties)
{
    mImpl->vkGetPhysicalDeviceExternalBufferProperties(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceExternalFenceProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
    mImpl->vkGetPhysicalDeviceExternalFenceProperties(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetPhysicalDeviceExternalSemaphoreProperties(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    mImpl->vkGetPhysicalDeviceExternalSemaphoreProperties(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
}
#endif
#ifdef VK_VERSION_1_1
void VkDecoderSnapshot::vkGetDescriptorSetLayoutSupport(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
    mImpl->vkGetDescriptorSetLayoutSupport(snapshotTraceBegin, snapshotTraceBytes, pool, device, pCreateInfo, pSupport);
}
#endif
#ifdef VK_KHR_surface
void VkDecoderSnapshot::vkDestroySurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkSurfaceKHR surface,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroySurfaceKHR(snapshotTraceBegin, snapshotTraceBytes, pool, instance, surface, pAllocator);
}
#endif
#ifdef VK_KHR_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceSurfaceSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    VkSurfaceKHR surface,
    VkBool32* pSupported)
{
    mImpl->vkGetPhysicalDeviceSurfaceSupportKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, queueFamilyIndex, surface, pSupported);
}
#endif
#ifdef VK_KHR_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilitiesKHR* pSurfaceCapabilities)
{
    mImpl->vkGetPhysicalDeviceSurfaceCapabilitiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, surface, pSurfaceCapabilities);
}
#endif
#ifdef VK_KHR_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceSurfaceFormatsKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormatKHR* pSurfaceFormats)
{
    mImpl->vkGetPhysicalDeviceSurfaceFormatsKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
}
#endif
#ifdef VK_KHR_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceSurfacePresentModesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pPresentModeCount,
    VkPresentModeKHR* pPresentModes)
{
    mImpl->vkGetPhysicalDeviceSurfacePresentModesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, surface, pPresentModeCount, pPresentModes);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkCreateSwapchainKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSwapchainCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchain)
{
    mImpl->vkCreateSwapchainKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pSwapchain);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkDestroySwapchainKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSwapchainKHR swapchain,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroySwapchainKHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, swapchain, pAllocator);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkGetSwapchainImagesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint32_t* pSwapchainImageCount,
    VkImage* pSwapchainImages)
{
    mImpl->vkGetSwapchainImagesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, swapchain, pSwapchainImageCount, pSwapchainImages);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkAcquireNextImageKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint64_t timeout,
    VkSemaphore semaphore,
    VkFence fence,
    uint32_t* pImageIndex)
{
    mImpl->vkAcquireNextImageKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, swapchain, timeout, semaphore, fence, pImageIndex);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkQueuePresentKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue,
    const VkPresentInfoKHR* pPresentInfo)
{
    mImpl->vkQueuePresentKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, queue, pPresentInfo);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkGetDeviceGroupPresentCapabilitiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities)
{
    mImpl->vkGetDeviceGroupPresentCapabilitiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pDeviceGroupPresentCapabilities);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkGetDeviceGroupSurfacePresentModesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSurfaceKHR surface,
    VkDeviceGroupPresentModeFlagsKHR* pModes)
{
    mImpl->vkGetDeviceGroupSurfacePresentModesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, surface, pModes);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkGetPhysicalDevicePresentRectanglesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    uint32_t* pRectCount,
    VkRect2D* pRects)
{
    mImpl->vkGetPhysicalDevicePresentRectanglesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, surface, pRectCount, pRects);
}
#endif
#ifdef VK_KHR_swapchain
void VkDecoderSnapshot::vkAcquireNextImage2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkAcquireNextImageInfoKHR* pAcquireInfo,
    uint32_t* pImageIndex)
{
    mImpl->vkAcquireNextImage2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pAcquireInfo, pImageIndex);
}
#endif
#ifdef VK_KHR_display
void VkDecoderSnapshot::vkGetPhysicalDeviceDisplayPropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPropertiesKHR* pProperties)
{
    mImpl->vkGetPhysicalDeviceDisplayPropertiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pPropertyCount, pProperties);
}
#endif
#ifdef VK_KHR_display
void VkDecoderSnapshot::vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlanePropertiesKHR* pProperties)
{
    mImpl->vkGetPhysicalDeviceDisplayPlanePropertiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pPropertyCount, pProperties);
}
#endif
#ifdef VK_KHR_display
void VkDecoderSnapshot::vkGetDisplayPlaneSupportedDisplaysKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t planeIndex,
    uint32_t* pDisplayCount,
    VkDisplayKHR* pDisplays)
{
    mImpl->vkGetDisplayPlaneSupportedDisplaysKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, planeIndex, pDisplayCount, pDisplays);
}
#endif
#ifdef VK_KHR_display
void VkDecoderSnapshot::vkGetDisplayModePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModePropertiesKHR* pProperties)
{
    mImpl->vkGetDisplayModePropertiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, display, pPropertyCount, pProperties);
}
#endif
#ifdef VK_KHR_display
void VkDecoderSnapshot::vkCreateDisplayModeKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    const VkDisplayModeCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDisplayModeKHR* pMode)
{
    mImpl->vkCreateDisplayModeKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, display, pCreateInfo, pAllocator, pMode);
}
#endif
#ifdef VK_KHR_display
void VkDecoderSnapshot::vkGetDisplayPlaneCapabilitiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayModeKHR mode,
    uint32_t planeIndex,
    VkDisplayPlaneCapabilitiesKHR* pCapabilities)
{
    mImpl->vkGetDisplayPlaneCapabilitiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, mode, planeIndex, pCapabilities);
}
#endif
#ifdef VK_KHR_display
void VkDecoderSnapshot::vkCreateDisplayPlaneSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateDisplayPlaneSurfaceKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_KHR_display_swapchain
void VkDecoderSnapshot::vkCreateSharedSwapchainsKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainCreateInfoKHR* pCreateInfos,
    const VkAllocationCallbacks* pAllocator,
    VkSwapchainKHR* pSwapchains)
{
    mImpl->vkCreateSharedSwapchainsKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
}
#endif
#ifdef VK_KHR_xlib_surface
void VkDecoderSnapshot::vkCreateXlibSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateXlibSurfaceKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_KHR_xlib_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceXlibPresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    Display* dpy,
    VisualID visualID)
{
    mImpl->vkGetPhysicalDeviceXlibPresentationSupportKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, queueFamilyIndex, dpy, visualID);
}
#endif
#ifdef VK_KHR_xcb_surface
void VkDecoderSnapshot::vkCreateXcbSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateXcbSurfaceKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_KHR_xcb_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceXcbPresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    xcb_connection_t* connection,
    xcb_visualid_t visual_id)
{
    mImpl->vkGetPhysicalDeviceXcbPresentationSupportKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, queueFamilyIndex, connection, visual_id);
}
#endif
#ifdef VK_KHR_wayland_surface
void VkDecoderSnapshot::vkCreateWaylandSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateWaylandSurfaceKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_KHR_wayland_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceWaylandPresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    wl_display* display)
{
    mImpl->vkGetPhysicalDeviceWaylandPresentationSupportKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, queueFamilyIndex, display);
}
#endif
#ifdef VK_KHR_mir_surface
void VkDecoderSnapshot::vkCreateMirSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkMirSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateMirSurfaceKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_KHR_mir_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceMirPresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex,
    MirConnection* connection)
{
    mImpl->vkGetPhysicalDeviceMirPresentationSupportKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, queueFamilyIndex, connection);
}
#endif
#ifdef VK_KHR_android_surface
void VkDecoderSnapshot::vkCreateAndroidSurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateAndroidSurfaceKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_KHR_win32_surface
void VkDecoderSnapshot::vkCreateWin32SurfaceKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateWin32SurfaceKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_KHR_win32_surface
void VkDecoderSnapshot::vkGetPhysicalDeviceWin32PresentationSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkBool32 input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t queueFamilyIndex)
{
    mImpl->vkGetPhysicalDeviceWin32PresentationSupportKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, queueFamilyIndex);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceFeatures2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceFeatures2* pFeatures)
{
    mImpl->vkGetPhysicalDeviceFeatures2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pFeatures);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceProperties2* pProperties)
{
    mImpl->vkGetPhysicalDeviceProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pProperties);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceFormatProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkFormatProperties2* pFormatProperties)
{
    mImpl->vkGetPhysicalDeviceFormatProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, format, pFormatProperties);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceImageFormatProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
    VkImageFormatProperties2* pImageFormatProperties)
{
    mImpl->vkGetPhysicalDeviceImageFormatProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pImageFormatInfo, pImageFormatProperties);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceQueueFamilyProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    uint32_t* pQueueFamilyPropertyCount,
    VkQueueFamilyProperties2* pQueueFamilyProperties)
{
    mImpl->vkGetPhysicalDeviceQueueFamilyProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceMemoryProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkPhysicalDeviceMemoryProperties2* pMemoryProperties)
{
    mImpl->vkGetPhysicalDeviceMemoryProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pMemoryProperties);
}
#endif
#ifdef VK_KHR_get_physical_device_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceSparseImageFormatProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
    uint32_t* pPropertyCount,
    VkSparseImageFormatProperties2* pProperties)
{
    mImpl->vkGetPhysicalDeviceSparseImageFormatProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pFormatInfo, pPropertyCount, pProperties);
}
#endif
#ifdef VK_KHR_device_group
void VkDecoderSnapshot::vkGetDeviceGroupPeerMemoryFeaturesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t heapIndex,
    uint32_t localDeviceIndex,
    uint32_t remoteDeviceIndex,
    VkPeerMemoryFeatureFlags* pPeerMemoryFeatures)
{
    mImpl->vkGetDeviceGroupPeerMemoryFeaturesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
}
#endif
#ifdef VK_KHR_device_group
void VkDecoderSnapshot::vkCmdSetDeviceMaskKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t deviceMask)
{
    mImpl->vkCmdSetDeviceMaskKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, deviceMask);
}
#endif
#ifdef VK_KHR_device_group
void VkDecoderSnapshot::vkCmdDispatchBaseKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t baseGroupX,
    uint32_t baseGroupY,
    uint32_t baseGroupZ,
    uint32_t groupCountX,
    uint32_t groupCountY,
    uint32_t groupCountZ)
{
    mImpl->vkCmdDispatchBaseKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
#endif
#ifdef VK_KHR_maintenance1
void VkDecoderSnapshot::vkTrimCommandPoolKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkCommandPool commandPool,
    VkCommandPoolTrimFlags flags)
{
    mImpl->vkTrimCommandPoolKHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, commandPool, flags);
}
#endif
#ifdef VK_KHR_device_group_creation
void VkDecoderSnapshot::vkEnumeratePhysicalDeviceGroupsKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    uint32_t* pPhysicalDeviceGroupCount,
    VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties)
{
    mImpl->vkEnumeratePhysicalDeviceGroupsKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
}
#endif
#ifdef VK_KHR_external_memory_capabilities
void VkDecoderSnapshot::vkGetPhysicalDeviceExternalBufferPropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,
    VkExternalBufferProperties* pExternalBufferProperties)
{
    mImpl->vkGetPhysicalDeviceExternalBufferPropertiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
}
#endif
#ifdef VK_KHR_external_memory_win32
void VkDecoderSnapshot::vkGetMemoryWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    mImpl->vkGetMemoryWin32HandleKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pGetWin32HandleInfo, pHandle);
}
#endif
#ifdef VK_KHR_external_memory_win32
void VkDecoderSnapshot::vkGetMemoryWin32HandlePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    HANDLE handle,
    VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties)
{
    mImpl->vkGetMemoryWin32HandlePropertiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, handleType, handle, pMemoryWin32HandleProperties);
}
#endif
#ifdef VK_KHR_external_memory_fd
void VkDecoderSnapshot::vkGetMemoryFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkMemoryGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    mImpl->vkGetMemoryFdKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pGetFdInfo, pFd);
}
#endif
#ifdef VK_KHR_external_memory_fd
void VkDecoderSnapshot::vkGetMemoryFdPropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    int fd,
    VkMemoryFdPropertiesKHR* pMemoryFdProperties)
{
    mImpl->vkGetMemoryFdPropertiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, handleType, fd, pMemoryFdProperties);
}
#endif
#ifdef VK_KHR_external_semaphore_capabilities
void VkDecoderSnapshot::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
    VkExternalSemaphoreProperties* pExternalSemaphoreProperties)
{
    mImpl->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
}
#endif
#ifdef VK_KHR_external_semaphore_win32
void VkDecoderSnapshot::vkImportSemaphoreWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo)
{
    mImpl->vkImportSemaphoreWin32HandleKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pImportSemaphoreWin32HandleInfo);
}
#endif
#ifdef VK_KHR_external_semaphore_win32
void VkDecoderSnapshot::vkGetSemaphoreWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    mImpl->vkGetSemaphoreWin32HandleKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pGetWin32HandleInfo, pHandle);
}
#endif
#ifdef VK_KHR_external_semaphore_fd
void VkDecoderSnapshot::vkImportSemaphoreFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo)
{
    mImpl->vkImportSemaphoreFdKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pImportSemaphoreFdInfo);
}
#endif
#ifdef VK_KHR_external_semaphore_fd
void VkDecoderSnapshot::vkGetSemaphoreFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSemaphoreGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    mImpl->vkGetSemaphoreFdKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pGetFdInfo, pFd);
}
#endif
#ifdef VK_KHR_push_descriptor
void VkDecoderSnapshot::vkCmdPushDescriptorSetKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineBindPoint pipelineBindPoint,
    VkPipelineLayout layout,
    uint32_t set,
    uint32_t descriptorWriteCount,
    const VkWriteDescriptorSet* pDescriptorWrites)
{
    mImpl->vkCmdPushDescriptorSetKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
}
#endif
#ifdef VK_KHR_push_descriptor
void VkDecoderSnapshot::vkCmdPushDescriptorSetWithTemplateKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    VkPipelineLayout layout,
    uint32_t set,
    const void* pData)
{
    mImpl->vkCmdPushDescriptorSetWithTemplateKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, descriptorUpdateTemplate, layout, set, pData);
}
#endif
#ifdef VK_KHR_descriptor_update_template
void VkDecoderSnapshot::vkCreateDescriptorUpdateTemplateKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
{
    mImpl->vkCreateDescriptorUpdateTemplateKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
}
#endif
#ifdef VK_KHR_descriptor_update_template
void VkDecoderSnapshot::vkDestroyDescriptorUpdateTemplateKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyDescriptorUpdateTemplateKHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorUpdateTemplate, pAllocator);
}
#endif
#ifdef VK_KHR_descriptor_update_template
void VkDecoderSnapshot::vkUpdateDescriptorSetWithTemplateKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    const void* pData)
{
    mImpl->vkUpdateDescriptorSetWithTemplateKHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorSet, descriptorUpdateTemplate, pData);
}
#endif
#ifdef VK_KHR_create_renderpass2
void VkDecoderSnapshot::vkCreateRenderPass2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkRenderPassCreateInfo2KHR* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkRenderPass* pRenderPass)
{
    mImpl->vkCreateRenderPass2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pRenderPass);
}
#endif
#ifdef VK_KHR_create_renderpass2
void VkDecoderSnapshot::vkCmdBeginRenderPass2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkRenderPassBeginInfo* pRenderPassBegin,
    const VkSubpassBeginInfoKHR* pSubpassBeginInfo)
{
    mImpl->vkCmdBeginRenderPass2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
}
#endif
#ifdef VK_KHR_create_renderpass2
void VkDecoderSnapshot::vkCmdNextSubpass2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
    const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
    mImpl->vkCmdNextSubpass2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
}
#endif
#ifdef VK_KHR_create_renderpass2
void VkDecoderSnapshot::vkCmdEndRenderPass2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkSubpassEndInfoKHR* pSubpassEndInfo)
{
    mImpl->vkCmdEndRenderPass2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pSubpassEndInfo);
}
#endif
#ifdef VK_KHR_shared_presentable_image
void VkDecoderSnapshot::vkGetSwapchainStatusKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain)
{
    mImpl->vkGetSwapchainStatusKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, swapchain);
}
#endif
#ifdef VK_KHR_external_fence_capabilities
void VkDecoderSnapshot::vkGetPhysicalDeviceExternalFencePropertiesKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,
    VkExternalFenceProperties* pExternalFenceProperties)
{
    mImpl->vkGetPhysicalDeviceExternalFencePropertiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
}
#endif
#ifdef VK_KHR_external_fence_win32
void VkDecoderSnapshot::vkImportFenceWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo)
{
    mImpl->vkImportFenceWin32HandleKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pImportFenceWin32HandleInfo);
}
#endif
#ifdef VK_KHR_external_fence_win32
void VkDecoderSnapshot::vkGetFenceWin32HandleKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo,
    HANDLE* pHandle)
{
    mImpl->vkGetFenceWin32HandleKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pGetWin32HandleInfo, pHandle);
}
#endif
#ifdef VK_KHR_external_fence_fd
void VkDecoderSnapshot::vkImportFenceFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImportFenceFdInfoKHR* pImportFenceFdInfo)
{
    mImpl->vkImportFenceFdKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pImportFenceFdInfo);
}
#endif
#ifdef VK_KHR_external_fence_fd
void VkDecoderSnapshot::vkGetFenceFdKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkFenceGetFdInfoKHR* pGetFdInfo,
    int* pFd)
{
    mImpl->vkGetFenceFdKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pGetFdInfo, pFd);
}
#endif
#ifdef VK_KHR_get_surface_capabilities2
void VkDecoderSnapshot::vkGetPhysicalDeviceSurfaceCapabilities2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    VkSurfaceCapabilities2KHR* pSurfaceCapabilities)
{
    mImpl->vkGetPhysicalDeviceSurfaceCapabilities2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
}
#endif
#ifdef VK_KHR_get_surface_capabilities2
void VkDecoderSnapshot::vkGetPhysicalDeviceSurfaceFormats2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
    uint32_t* pSurfaceFormatCount,
    VkSurfaceFormat2KHR* pSurfaceFormats)
{
    mImpl->vkGetPhysicalDeviceSurfaceFormats2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
}
#endif
#ifdef VK_KHR_get_display_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceDisplayProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayProperties2KHR* pProperties)
{
    mImpl->vkGetPhysicalDeviceDisplayProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pPropertyCount, pProperties);
}
#endif
#ifdef VK_KHR_get_display_properties2
void VkDecoderSnapshot::vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    uint32_t* pPropertyCount,
    VkDisplayPlaneProperties2KHR* pProperties)
{
    mImpl->vkGetPhysicalDeviceDisplayPlaneProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pPropertyCount, pProperties);
}
#endif
#ifdef VK_KHR_get_display_properties2
void VkDecoderSnapshot::vkGetDisplayModeProperties2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display,
    uint32_t* pPropertyCount,
    VkDisplayModeProperties2KHR* pProperties)
{
    mImpl->vkGetDisplayModeProperties2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, display, pPropertyCount, pProperties);
}
#endif
#ifdef VK_KHR_get_display_properties2
void VkDecoderSnapshot::vkGetDisplayPlaneCapabilities2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,
    VkDisplayPlaneCapabilities2KHR* pCapabilities)
{
    mImpl->vkGetDisplayPlaneCapabilities2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, pDisplayPlaneInfo, pCapabilities);
}
#endif
#ifdef VK_KHR_get_memory_requirements2
void VkDecoderSnapshot::vkGetImageMemoryRequirements2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkImageMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    mImpl->vkGetImageMemoryRequirements2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, pInfo, pMemoryRequirements);
}
#endif
#ifdef VK_KHR_get_memory_requirements2
void VkDecoderSnapshot::vkGetBufferMemoryRequirements2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkBufferMemoryRequirementsInfo2* pInfo,
    VkMemoryRequirements2* pMemoryRequirements)
{
    mImpl->vkGetBufferMemoryRequirements2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, pInfo, pMemoryRequirements);
}
#endif
#ifdef VK_KHR_get_memory_requirements2
void VkDecoderSnapshot::vkGetImageSparseMemoryRequirements2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkImageSparseMemoryRequirementsInfo2* pInfo,
    uint32_t* pSparseMemoryRequirementCount,
    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements)
{
    mImpl->vkGetImageSparseMemoryRequirements2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
}
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
void VkDecoderSnapshot::vkCreateSamplerYcbcrConversionKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSamplerYcbcrConversion* pYcbcrConversion)
{
    mImpl->vkCreateSamplerYcbcrConversionKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pYcbcrConversion);
}
#endif
#ifdef VK_KHR_sampler_ycbcr_conversion
void VkDecoderSnapshot::vkDestroySamplerYcbcrConversionKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkSamplerYcbcrConversion ycbcrConversion,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroySamplerYcbcrConversionKHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, ycbcrConversion, pAllocator);
}
#endif
#ifdef VK_KHR_bind_memory2
void VkDecoderSnapshot::vkBindBufferMemory2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindBufferMemoryInfo* pBindInfos)
{
    mImpl->vkBindBufferMemory2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, bindInfoCount, pBindInfos);
}
#endif
#ifdef VK_KHR_bind_memory2
void VkDecoderSnapshot::vkBindImageMemory2KHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    uint32_t bindInfoCount,
    const VkBindImageMemoryInfo* pBindInfos)
{
    mImpl->vkBindImageMemory2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, bindInfoCount, pBindInfos);
}
#endif
#ifdef VK_KHR_maintenance3
void VkDecoderSnapshot::vkGetDescriptorSetLayoutSupportKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
    VkDescriptorSetLayoutSupport* pSupport)
{
    mImpl->vkGetDescriptorSetLayoutSupportKHR(snapshotTraceBegin, snapshotTraceBytes, pool, device, pCreateInfo, pSupport);
}
#endif
#ifdef VK_KHR_draw_indirect_count
void VkDecoderSnapshot::vkCmdDrawIndirectCountKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    mImpl->vkCmdDrawIndirectCountKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
#endif
#ifdef VK_KHR_draw_indirect_count
void VkDecoderSnapshot::vkCmdDrawIndexedIndirectCountKHR(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    mImpl->vkCmdDrawIndexedIndirectCountKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
#endif
#ifdef VK_ANDROID_native_buffer
void VkDecoderSnapshot::vkGetSwapchainGrallocUsageANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkFormat format,
    VkImageUsageFlags imageUsage,
    int* grallocUsage)
{
    mImpl->vkGetSwapchainGrallocUsageANDROID(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, format, imageUsage, grallocUsage);
}
#endif
#ifdef VK_ANDROID_native_buffer
void VkDecoderSnapshot::vkAcquireImageANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkImage image,
    int nativeFenceFd,
    VkSemaphore semaphore,
    VkFence fence)
{
    mImpl->vkAcquireImageANDROID(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, image, nativeFenceFd, semaphore, fence);
}
#endif
#ifdef VK_ANDROID_native_buffer
void VkDecoderSnapshot::vkQueueSignalReleaseImageANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkQueue queue,
    uint32_t waitSemaphoreCount,
    const VkSemaphore* pWaitSemaphores,
    VkImage image,
    int* pNativeFenceFd)
{
    mImpl->vkQueueSignalReleaseImageANDROID(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd);
}
#endif
#ifdef VK_EXT_debug_report
void VkDecoderSnapshot::vkCreateDebugReportCallbackEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDebugReportCallbackEXT* pCallback)
{
    mImpl->vkCreateDebugReportCallbackEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pCallback);
}
#endif
#ifdef VK_EXT_debug_report
void VkDecoderSnapshot::vkDestroyDebugReportCallbackEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkDebugReportCallbackEXT callback,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyDebugReportCallbackEXT(snapshotTraceBegin, snapshotTraceBytes, pool, instance, callback, pAllocator);
}
#endif
#ifdef VK_EXT_debug_report
void VkDecoderSnapshot::vkDebugReportMessageEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkDebugReportFlagsEXT flags,
    VkDebugReportObjectTypeEXT objectType,
    uint64_t object,
    size_t location,
    int32_t messageCode,
    const char* pLayerPrefix,
    const char* pMessage)
{
    mImpl->vkDebugReportMessageEXT(snapshotTraceBegin, snapshotTraceBytes, pool, instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage);
}
#endif
#ifdef VK_EXT_debug_marker
void VkDecoderSnapshot::vkDebugMarkerSetObjectTagEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDebugMarkerObjectTagInfoEXT* pTagInfo)
{
    mImpl->vkDebugMarkerSetObjectTagEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pTagInfo);
}
#endif
#ifdef VK_EXT_debug_marker
void VkDecoderSnapshot::vkDebugMarkerSetObjectNameEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDebugMarkerObjectNameInfoEXT* pNameInfo)
{
    mImpl->vkDebugMarkerSetObjectNameEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pNameInfo);
}
#endif
#ifdef VK_EXT_debug_marker
void VkDecoderSnapshot::vkCmdDebugMarkerBeginEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    mImpl->vkCmdDebugMarkerBeginEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pMarkerInfo);
}
#endif
#ifdef VK_EXT_debug_marker
void VkDecoderSnapshot::vkCmdDebugMarkerEndEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    mImpl->vkCmdDebugMarkerEndEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer);
}
#endif
#ifdef VK_EXT_debug_marker
void VkDecoderSnapshot::vkCmdDebugMarkerInsertEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkDebugMarkerMarkerInfoEXT* pMarkerInfo)
{
    mImpl->vkCmdDebugMarkerInsertEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pMarkerInfo);
}
#endif
#ifdef VK_AMD_draw_indirect_count
void VkDecoderSnapshot::vkCmdDrawIndirectCountAMD(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    mImpl->vkCmdDrawIndirectCountAMD(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
#endif
#ifdef VK_AMD_draw_indirect_count
void VkDecoderSnapshot::vkCmdDrawIndexedIndirectCountAMD(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkBuffer buffer,
    VkDeviceSize offset,
    VkBuffer countBuffer,
    VkDeviceSize countBufferOffset,
    uint32_t maxDrawCount,
    uint32_t stride)
{
    mImpl->vkCmdDrawIndexedIndirectCountAMD(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
}
#endif
#ifdef VK_AMD_shader_info
void VkDecoderSnapshot::vkGetShaderInfoAMD(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkPipeline pipeline,
    VkShaderStageFlagBits shaderStage,
    VkShaderInfoTypeAMD infoType,
    size_t* pInfoSize,
    void* pInfo)
{
    mImpl->vkGetShaderInfoAMD(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
}
#endif
#ifdef VK_NV_external_memory_capabilities
void VkDecoderSnapshot::vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkFormat format,
    VkImageType type,
    VkImageTiling tiling,
    VkImageUsageFlags usage,
    VkImageCreateFlags flags,
    VkExternalMemoryHandleTypeFlagsNV externalHandleType,
    VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties)
{
    mImpl->vkGetPhysicalDeviceExternalImageFormatPropertiesNV(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties);
}
#endif
#ifdef VK_NV_external_memory_win32
void VkDecoderSnapshot::vkGetMemoryWin32HandleNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    VkExternalMemoryHandleTypeFlagsNV handleType,
    HANDLE* pHandle)
{
    mImpl->vkGetMemoryWin32HandleNV(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, memory, handleType, pHandle);
}
#endif
#ifdef VK_NN_vi_surface
void VkDecoderSnapshot::vkCreateViSurfaceNN(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkViSurfaceCreateInfoNN* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateViSurfaceNN(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_EXT_conditional_rendering
void VkDecoderSnapshot::vkCmdBeginConditionalRenderingEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin)
{
    mImpl->vkCmdBeginConditionalRenderingEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pConditionalRenderingBegin);
}
#endif
#ifdef VK_EXT_conditional_rendering
void VkDecoderSnapshot::vkCmdEndConditionalRenderingEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    mImpl->vkCmdEndConditionalRenderingEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkCmdProcessCommandsNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo)
{
    mImpl->vkCmdProcessCommandsNVX(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pProcessCommandsInfo);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkCmdReserveSpaceForCommandsNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo)
{
    mImpl->vkCmdReserveSpaceForCommandsNVX(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pReserveSpaceInfo);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkCreateIndirectCommandsLayoutNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout)
{
    mImpl->vkCreateIndirectCommandsLayoutNVX(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkDestroyIndirectCommandsLayoutNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkIndirectCommandsLayoutNVX indirectCommandsLayout,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyIndirectCommandsLayoutNVX(snapshotTraceBegin, snapshotTraceBytes, pool, device, indirectCommandsLayout, pAllocator);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkCreateObjectTableNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkObjectTableCreateInfoNVX* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkObjectTableNVX* pObjectTable)
{
    mImpl->vkCreateObjectTableNVX(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pObjectTable);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkDestroyObjectTableNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkObjectTableNVX objectTable,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyObjectTableNVX(snapshotTraceBegin, snapshotTraceBytes, pool, device, objectTable, pAllocator);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkRegisterObjectsNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkObjectTableNVX objectTable,
    uint32_t objectCount,
    const VkObjectTableEntryNVX* const* ppObjectTableEntries,
    const uint32_t* pObjectIndices)
{
    mImpl->vkRegisterObjectsNVX(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkUnregisterObjectsNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkObjectTableNVX objectTable,
    uint32_t objectCount,
    const VkObjectEntryTypeNVX* pObjectEntryTypes,
    const uint32_t* pObjectIndices)
{
    mImpl->vkUnregisterObjectsNVX(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
}
#endif
#ifdef VK_NVX_device_generated_commands
void VkDecoderSnapshot::vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
    VkDeviceGeneratedCommandsLimitsNVX* pLimits)
{
    mImpl->vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, pFeatures, pLimits);
}
#endif
#ifdef VK_NV_clip_space_w_scaling
void VkDecoderSnapshot::vkCmdSetViewportWScalingNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstViewport,
    uint32_t viewportCount,
    const VkViewportWScalingNV* pViewportWScalings)
{
    mImpl->vkCmdSetViewportWScalingNV(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, firstViewport, viewportCount, pViewportWScalings);
}
#endif
#ifdef VK_EXT_direct_mode_display
void VkDecoderSnapshot::vkReleaseDisplayEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkDisplayKHR display)
{
    mImpl->vkReleaseDisplayEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, display);
}
#endif
#ifdef VK_EXT_acquire_xlib_display
void VkDecoderSnapshot::vkAcquireXlibDisplayEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    Display* dpy,
    VkDisplayKHR display)
{
    mImpl->vkAcquireXlibDisplayEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, dpy, display);
}
#endif
#ifdef VK_EXT_acquire_xlib_display
void VkDecoderSnapshot::vkGetRandROutputDisplayEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    Display* dpy,
    RROutput rrOutput,
    VkDisplayKHR* pDisplay)
{
    mImpl->vkGetRandROutputDisplayEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, dpy, rrOutput, pDisplay);
}
#endif
#ifdef VK_EXT_display_surface_counter
void VkDecoderSnapshot::vkGetPhysicalDeviceSurfaceCapabilities2EXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkPhysicalDevice physicalDevice,
    VkSurfaceKHR surface,
    VkSurfaceCapabilities2EXT* pSurfaceCapabilities)
{
    mImpl->vkGetPhysicalDeviceSurfaceCapabilities2EXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice, surface, pSurfaceCapabilities);
}
#endif
#ifdef VK_EXT_display_control
void VkDecoderSnapshot::vkDisplayPowerControlEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDisplayKHR display,
    const VkDisplayPowerInfoEXT* pDisplayPowerInfo)
{
    mImpl->vkDisplayPowerControlEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, display, pDisplayPowerInfo);
}
#endif
#ifdef VK_EXT_display_control
void VkDecoderSnapshot::vkRegisterDeviceEventEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDeviceEventInfoEXT* pDeviceEventInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    mImpl->vkRegisterDeviceEventEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pDeviceEventInfo, pAllocator, pFence);
}
#endif
#ifdef VK_EXT_display_control
void VkDecoderSnapshot::vkRegisterDisplayEventEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDisplayKHR display,
    const VkDisplayEventInfoEXT* pDisplayEventInfo,
    const VkAllocationCallbacks* pAllocator,
    VkFence* pFence)
{
    mImpl->vkRegisterDisplayEventEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, display, pDisplayEventInfo, pAllocator, pFence);
}
#endif
#ifdef VK_EXT_display_control
void VkDecoderSnapshot::vkGetSwapchainCounterEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    VkSurfaceCounterFlagBitsEXT counter,
    uint64_t* pCounterValue)
{
    mImpl->vkGetSwapchainCounterEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, swapchain, counter, pCounterValue);
}
#endif
#ifdef VK_GOOGLE_display_timing
void VkDecoderSnapshot::vkGetRefreshCycleDurationGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties)
{
    mImpl->vkGetRefreshCycleDurationGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, swapchain, pDisplayTimingProperties);
}
#endif
#ifdef VK_GOOGLE_display_timing
void VkDecoderSnapshot::vkGetPastPresentationTimingGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkSwapchainKHR swapchain,
    uint32_t* pPresentationTimingCount,
    VkPastPresentationTimingGOOGLE* pPresentationTimings)
{
    mImpl->vkGetPastPresentationTimingGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, swapchain, pPresentationTimingCount, pPresentationTimings);
}
#endif
#ifdef VK_EXT_discard_rectangles
void VkDecoderSnapshot::vkCmdSetDiscardRectangleEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t firstDiscardRectangle,
    uint32_t discardRectangleCount,
    const VkRect2D* pDiscardRectangles)
{
    mImpl->vkCmdSetDiscardRectangleEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles);
}
#endif
#ifdef VK_EXT_hdr_metadata
void VkDecoderSnapshot::vkSetHdrMetadataEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    uint32_t swapchainCount,
    const VkSwapchainKHR* pSwapchains,
    const VkHdrMetadataEXT* pMetadata)
{
    mImpl->vkSetHdrMetadataEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device, swapchainCount, pSwapchains, pMetadata);
}
#endif
#ifdef VK_MVK_ios_surface
void VkDecoderSnapshot::vkCreateIOSSurfaceMVK(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateIOSSurfaceMVK(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_MVK_macos_surface
void VkDecoderSnapshot::vkCreateMacOSSurfaceMVK(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkSurfaceKHR* pSurface)
{
    mImpl->vkCreateMacOSSurfaceMVK(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pSurface);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkSetDebugUtilsObjectNameEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDebugUtilsObjectNameInfoEXT* pNameInfo)
{
    mImpl->vkSetDebugUtilsObjectNameEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pNameInfo);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkSetDebugUtilsObjectTagEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkDebugUtilsObjectTagInfoEXT* pTagInfo)
{
    mImpl->vkSetDebugUtilsObjectTagEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pTagInfo);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkQueueBeginDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    mImpl->vkQueueBeginDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, queue, pLabelInfo);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkQueueEndDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue)
{
    mImpl->vkQueueEndDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, queue);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkQueueInsertDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    mImpl->vkQueueInsertDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, queue, pLabelInfo);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkCmdBeginDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    mImpl->vkCmdBeginDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pLabelInfo);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkCmdEndDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    mImpl->vkCmdEndDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkCmdInsertDebugUtilsLabelEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkDebugUtilsLabelEXT* pLabelInfo)
{
    mImpl->vkCmdInsertDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pLabelInfo);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkCreateDebugUtilsMessengerEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkInstance instance,
    const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkDebugUtilsMessengerEXT* pMessenger)
{
    mImpl->vkCreateDebugUtilsMessengerEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, instance, pCreateInfo, pAllocator, pMessenger);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkDestroyDebugUtilsMessengerEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkDebugUtilsMessengerEXT messenger,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyDebugUtilsMessengerEXT(snapshotTraceBegin, snapshotTraceBytes, pool, instance, messenger, pAllocator);
}
#endif
#ifdef VK_EXT_debug_utils
void VkDecoderSnapshot::vkSubmitDebugUtilsMessageEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkInstance instance,
    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
    VkDebugUtilsMessageTypeFlagsEXT messageTypes,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData)
{
    mImpl->vkSubmitDebugUtilsMessageEXT(snapshotTraceBegin, snapshotTraceBytes, pool, instance, messageSeverity, messageTypes, pCallbackData);
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void VkDecoderSnapshot::vkGetAndroidHardwareBufferPropertiesANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const AHardwareBuffer* buffer,
    VkAndroidHardwareBufferPropertiesANDROID* pProperties)
{
    mImpl->vkGetAndroidHardwareBufferPropertiesANDROID(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, buffer, pProperties);
}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
void VkDecoderSnapshot::vkGetMemoryAndroidHardwareBufferANDROID(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
    AHardwareBuffer** pBuffer)
{
    mImpl->vkGetMemoryAndroidHardwareBufferANDROID(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pInfo, pBuffer);
}
#endif
#ifdef VK_EXT_sample_locations
void VkDecoderSnapshot::vkCmdSetSampleLocationsEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkSampleLocationsInfoEXT* pSampleLocationsInfo)
{
    mImpl->vkCmdSetSampleLocationsEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pSampleLocationsInfo);
}
#endif
#ifdef VK_EXT_sample_locations
void VkDecoderSnapshot::vkGetPhysicalDeviceMultisamplePropertiesEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkPhysicalDevice physicalDevice,
    VkSampleCountFlagBits samples,
    VkMultisamplePropertiesEXT* pMultisampleProperties)
{
    mImpl->vkGetPhysicalDeviceMultisamplePropertiesEXT(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice, samples, pMultisampleProperties);
}
#endif
#ifdef VK_EXT_validation_cache
void VkDecoderSnapshot::vkCreateValidationCacheEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkValidationCacheCreateInfoEXT* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkValidationCacheEXT* pValidationCache)
{
    mImpl->vkCreateValidationCacheEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pValidationCache);
}
#endif
#ifdef VK_EXT_validation_cache
void VkDecoderSnapshot::vkDestroyValidationCacheEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkValidationCacheEXT validationCache,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkDestroyValidationCacheEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device, validationCache, pAllocator);
}
#endif
#ifdef VK_EXT_validation_cache
void VkDecoderSnapshot::vkMergeValidationCachesEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkValidationCacheEXT dstCache,
    uint32_t srcCacheCount,
    const VkValidationCacheEXT* pSrcCaches)
{
    mImpl->vkMergeValidationCachesEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, dstCache, srcCacheCount, pSrcCaches);
}
#endif
#ifdef VK_EXT_validation_cache
void VkDecoderSnapshot::vkGetValidationCacheDataEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkValidationCacheEXT validationCache,
    size_t* pDataSize,
    void* pData)
{
    mImpl->vkGetValidationCacheDataEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, validationCache, pDataSize, pData);
}
#endif
#ifdef VK_EXT_external_memory_host
void VkDecoderSnapshot::vkGetMemoryHostPointerPropertiesEXT(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkExternalMemoryHandleTypeFlagBits handleType,
    const void* pHostPointer,
    VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties)
{
    mImpl->vkGetMemoryHostPointerPropertiesEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, handleType, pHostPointer, pMemoryHostPointerProperties);
}
#endif
#ifdef VK_AMD_buffer_marker
void VkDecoderSnapshot::vkCmdWriteBufferMarkerAMD(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkPipelineStageFlagBits pipelineStage,
    VkBuffer dstBuffer,
    VkDeviceSize dstOffset,
    uint32_t marker)
{
    mImpl->vkCmdWriteBufferMarkerAMD(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void VkDecoderSnapshot::vkCmdSetCheckpointNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const void* pCheckpointMarker)
{
    mImpl->vkCmdSetCheckpointNV(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pCheckpointMarker);
}
#endif
#ifdef VK_NV_device_diagnostic_checkpoints
void VkDecoderSnapshot::vkGetQueueCheckpointDataNV(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    uint32_t* pCheckpointDataCount,
    VkCheckpointDataNV* pCheckpointData)
{
    mImpl->vkGetQueueCheckpointDataNV(snapshotTraceBegin, snapshotTraceBytes, pool, queue, pCheckpointDataCount, pCheckpointData);
}
#endif
#ifdef VK_GOOGLE_address_space
void VkDecoderSnapshot::vkMapMemoryIntoAddressSpaceGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    uint64_t* pAddress)
{
    mImpl->vkMapMemoryIntoAddressSpaceGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, memory, pAddress);
}
#endif
#ifdef VK_GOOGLE_color_buffer
void VkDecoderSnapshot::vkRegisterImageColorBufferGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkImage image,
    uint32_t colorBuffer)
{
    mImpl->vkRegisterImageColorBufferGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, image, colorBuffer);
}
#endif
#ifdef VK_GOOGLE_color_buffer
void VkDecoderSnapshot::vkRegisterBufferColorBufferGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkBuffer buffer,
    uint32_t colorBuffer)
{
    mImpl->vkRegisterBufferColorBufferGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, buffer, colorBuffer);
}
#endif
#ifdef VK_GOOGLE_sized_descriptor_update_template
void VkDecoderSnapshot::vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkDescriptorSet descriptorSet,
    VkDescriptorUpdateTemplate descriptorUpdateTemplate,
    uint32_t imageInfoCount,
    uint32_t bufferInfoCount,
    uint32_t bufferViewCount,
    const uint32_t* pImageInfoEntryIndices,
    const uint32_t* pBufferInfoEntryIndices,
    const uint32_t* pBufferViewEntryIndices,
    const VkDescriptorImageInfo* pImageInfos,
    const VkDescriptorBufferInfo* pBufferInfos,
    const VkBufferView* pBufferViews)
{
    mImpl->vkUpdateDescriptorSetWithTemplateSizedGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorSet, descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount, pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews);
}
#endif
#ifdef VK_GOOGLE_async_command_buffers
void VkDecoderSnapshot::vkBeginCommandBufferAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    const VkCommandBufferBeginInfo* pBeginInfo)
{
    mImpl->vkBeginCommandBufferAsyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pBeginInfo);
}
#endif
#ifdef VK_GOOGLE_async_command_buffers
void VkDecoderSnapshot::vkEndCommandBufferAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer)
{
    mImpl->vkEndCommandBufferAsyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer);
}
#endif
#ifdef VK_GOOGLE_async_command_buffers
void VkDecoderSnapshot::vkResetCommandBufferAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    VkCommandBufferResetFlags flags)
{
    mImpl->vkResetCommandBufferAsyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, flags);
}
#endif
#ifdef VK_GOOGLE_async_command_buffers
void VkDecoderSnapshot::vkCommandBufferHostSyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkCommandBuffer commandBuffer,
    uint32_t needHostSync,
    uint32_t sequenceNumber)
{
    mImpl->vkCommandBufferHostSyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, needHostSync, sequenceNumber);
}
#endif
#ifdef VK_GOOGLE_create_resources_with_requirements
void VkDecoderSnapshot::vkCreateImageWithRequirementsGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkImageCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkImage* pImage,
    VkMemoryRequirements* pMemoryRequirements)
{
    mImpl->vkCreateImageWithRequirementsGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pImage, pMemoryRequirements);
}
#endif
#ifdef VK_GOOGLE_create_resources_with_requirements
void VkDecoderSnapshot::vkCreateBufferWithRequirementsGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    const VkBufferCreateInfo* pCreateInfo,
    const VkAllocationCallbacks* pAllocator,
    VkBuffer* pBuffer,
    VkMemoryRequirements* pMemoryRequirements)
{
    mImpl->vkCreateBufferWithRequirementsGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pCreateInfo, pAllocator, pBuffer, pMemoryRequirements);
}
#endif
#ifdef VK_GOOGLE_address_space_info
void VkDecoderSnapshot::vkGetMemoryHostAddressInfoGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    uint64_t* pAddress,
    uint64_t* pSize,
    uint64_t* pHostmemId)
{
    mImpl->vkGetMemoryHostAddressInfoGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, memory, pAddress, pSize, pHostmemId);
}
#endif
#ifdef VK_GOOGLE_free_memory_sync
void VkDecoderSnapshot::vkFreeMemorySyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkResult input_result,
    VkDevice device,
    VkDeviceMemory memory,
    const VkAllocationCallbacks* pAllocator)
{
    mImpl->vkFreeMemorySyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, memory, pAllocator);
}
#endif
#ifdef VK_GOOGLE_async_queue_submit
void VkDecoderSnapshot::vkQueueHostSyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    uint32_t needHostSync,
    uint32_t sequenceNumber)
{
    mImpl->vkQueueHostSyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, queue, needHostSync, sequenceNumber);
}
#endif
#ifdef VK_GOOGLE_async_queue_submit
void VkDecoderSnapshot::vkQueueSubmitAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    uint32_t submitCount,
    const VkSubmitInfo* pSubmits,
    VkFence fence)
{
    mImpl->vkQueueSubmitAsyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, queue, submitCount, pSubmits, fence);
}
#endif
#ifdef VK_GOOGLE_async_queue_submit
void VkDecoderSnapshot::vkQueueWaitIdleAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue)
{
    mImpl->vkQueueWaitIdleAsyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, queue);
}
#endif
#ifdef VK_GOOGLE_async_queue_submit
void VkDecoderSnapshot::vkQueueBindSparseAsyncGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkQueue queue,
    uint32_t bindInfoCount,
    const VkBindSparseInfo* pBindInfo,
    VkFence fence)
{
    mImpl->vkQueueBindSparseAsyncGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, queue, bindInfoCount, pBindInfo, fence);
}
#endif
#ifdef VK_GOOGLE_linear_image_layout
void VkDecoderSnapshot::vkGetLinearImageLayoutGOOGLE(
    const uint8_t* snapshotTraceBegin,
    size_t snapshotTraceBytes,
    android::base::BumpPool* pool,
    VkDevice device,
    VkFormat format,
    VkDeviceSize* pOffset,
    VkDeviceSize* pRowPitchAlignment)
{
    mImpl->vkGetLinearImageLayoutGOOGLE(snapshotTraceBegin, snapshotTraceBytes, pool, device, format, pOffset, pRowPitchAlignment);
}
#endif